Handling Blog Projects
Plan a blog launch like a project: write the scope, find the critical path and slack, turn working days into real dates, handle change requests calmly and communicate on a rhythm.
In this lesson you will
- Write a scope before any dates
- Find the critical path and slack
- Turn working days into dates
- Handle change requests calmly
About 24 minutes
Priya takes on a launch
Priya has agreed to launch a blog for her friend’s repair shop. There are posts to write, a site to set up, pages to build, a review and some fixes. Her friend asks one question: ‘When will it be done?’ A project is a set of jobs where some must wait for others. Managing it means knowing the order, the dates and what to do when something changes. This lesson gives you a method that works for a blog launch, a redesign or a content plan.
Start with a written scope
Before any dates, write down what is included and what is not. A scope might say: ten posts of about 800 words, five pages, one review round and one round of fixes. It also names what you need from the client, such as photos and facts, and by when. When a client later says ‘could you add a shop page?’ you can see that it is new work and treat it as a change, not as a favour.
Jobs, durations and what depends on what
List each job with how many working days it needs and which jobs must finish first. The program below does that for a made-up launch. It writes a plan, set-up, pages, review, fixes and launch, and turns the totals into real dates from Monday 16 November 2026, skipping weekends. Only a job’s own dependencies matter: writing and set-up can happen at the same time, but the review needs both.
import numpy as np
# MADE-UP launch project: task -> (working days, depends on)
tasks = {
"brief": (1, []),
"plan": (2, ["brief"]),
"write": (5, ["plan"]),
"set up": (4, ["plan"]),
"pages": (2, ["set up"]),
"review": (3, ["write", "pages"]),
"fixes": (2, ["review"]),
"launch": (1, ["fixes"]),
}
def schedule(tasks):
done = {}
def finish(t):
if t not in done:
days, deps = tasks[t]
done[t] = max([finish(d) for d in deps], default=0) + days
return done[t]
return {t: finish(t) for t in tasks}
start = np.datetime64("2026-11-16") # a Monday
def report(tasks, label):
ends = schedule(tasks)
total = max(ends.values())
last = np.busday_offset(start, total - 1)
print(f"{label}: {total} working days, ends {last} ({np.datetime_as_string(last)[:10]})")
return ends
ends = report(tasks, "plan")
slack_write = ends["review"] - tasks["review"][0] - ends["write"]
print("slack on writing:", slack_write, "days")
tasks["write"] = (8, ["plan"])
report(tasks, "after 3 extra days of writing")
tasks["write"] = (5, ["plan"])
tasks["set up"] = (5, ["plan"])
report(tasks, "if set-up slips by 1")
plan: 15 working days, ends 2026-12-04 (2026-12-04)
slack on writing: 1 days
after 3 extra days of writing: 17 working days, ends 2026-12-08 (2026-12-08)
if set-up slips by 1: 16 working days, ends 2026-12-07 (2026-12-07)
The plan takes 15 working days, ending on 2026-12-04. The route that decides the end, called the critical path, goes through the brief, plan, set-up, pages, review, fixes and launch. Any delay on it moves the finish date by the same amount. Writing is not on that path. It has 1 day of slack, which means it can run one day late without moving the end date.
Now the changes. The client asks for three extra days of writing, perhaps two more posts. The writing path becomes longer than the set-up path, so the total grows to 17 days and the end moves to 2026-12-08. That is a two-day delay from a three-day request, because one day was absorbed by slack. If instead set-up slips by one day, the total becomes 16 days and the end moves to 2026-12-07. A delay on the critical path goes straight to the end date, while a delay off it may cost nothing. That is why you watch the critical path first.
Handle changes without drama
- Say in writing what the new request is and what it adds to the schedule and price.
- Show the new end date from the plan, so it is a fact and not a mood.
- Let the client choose: accept the change, swap it for something else or leave it for later.
- Update the plan only when they agree, and send them the new version.
- Keep a change log of what, when, who and what it cost.
Reviews take time
Waiting for a client is a job too. In the plan, a review takes three days, but if the client is late with feedback, your timeline moves. Say when you need their reply and what happens if it comes late, for example that the end date moves day for day. Send reminders politely and keep a record. Ask for feedback in one place, in one list, instead of many scattered messages.
Communicate on a rhythm
- A short update every week, even if nothing changed.
- Early warning when something is slipping, with the options you see.
- One shared place for files and decisions.
- A clear finish: a launch check, a handover and a thank-you.
- A note after launch about what you would do next and what you will not do unless asked.
Giving a single date and hoping. Dates built from a list of jobs are more honest. Give a date, say what it assumes and tell the client what would move it.
The project, tasks and dates are made up. Real projects have holidays, illness and surprises, so leave a buffer and keep checking. Dates here count working days from a Monday and ignore public holidays.
Practice for this lesson
Check what you learned
Five quick questions. Pick an answer and you will see straight away whether it is right and why.
What is the critical path?
- The shortest job
- The cheapest route
- A list of links
- The chain of jobs that decides the end date
A delay on it moves the finish date.
What is slack?
- Extra pay
- How much a job can slip without moving the end
- A spare client
- A kind of link
Writing could run one day late with no effect on the end date.
Why did three extra days of writing cost only two days?
- Writing is free
- Weekends were counted
- One day was absorbed by slack
- Reviews vanished
The slack soaked up one day.
What should you do when a client asks for more?
- Show what it adds, then let them choose
- Say yes silently
- Refuse always
- Hide the cost
Show the effect on date and price, and let the client decide.
Why write the scope first?
- To raise the price
- To avoid dates
- So a new request is seen as a change
- To skip reviews
A written scope shows what was agreed.
Summary
- Write the scope, including what you need from the client.
- The critical path decides the end date; slack is free room.
- Show the effect of changes on dates before agreeing.
- Communicate on a regular rhythm.
Questions
How much buffer should I add?
There is no fixed figure. Add some for review delays and surprises, and tell the client what the date assumes.
Do I need project software?
No. A list and a calendar are enough for most blog projects. A short program like this one can help you check the dates.
What if the client keeps changing things?
Return to the written scope, show what each change adds and let them choose. Offer a later phase for extra work.
