AdvancedLesson 29 of 305 min read

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

  1. Say in writing what the new request is and what it adds to the schedule and price.
  2. Show the new end date from the plan, so it is a fact and not a mood.
  3. Let the client choose: accept the change, swap it for something else or leave it for later.
  4. Update the plan only when they agree, and send them the new version.
  5. 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.
Common mistake: a date from the air

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.

Sample data only

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.

List the jobs of a project you have coming up. Give each a duration and what it waits for, then work out the end date and the one job that cannot slip.

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?

  1. The shortest job
  2. The cheapest route
  3. A list of links
  4. The chain of jobs that decides the end date

A delay on it moves the finish date.

What is slack?

  1. Extra pay
  2. How much a job can slip without moving the end
  3. A spare client
  4. 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?

  1. Writing is free
  2. Weekends were counted
  3. One day was absorbed by slack
  4. Reviews vanished

The slack soaked up one day.

What should you do when a client asks for more?

  1. Show what it adds, then let them choose
  2. Say yes silently
  3. Refuse always
  4. Hide the cost

Show the effect on date and price, and let the client decide.

Why write the scope first?

  1. To raise the price
  2. To avoid dates
  3. So a new request is seen as a change
  4. 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.

Next lesson

Lesson 30 is the Advanced capstone: a year plan with checks.

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.

Progress is saved in this browser.