Activity Sequencing

🎬 Activity Sequencing: Building Your Project’s Story

Imagine you’re making a movie. You can’t film the ending before the beginning, right? You need a sequence — a logical order where each scene flows into the next.

Activity Sequencing in project management works exactly the same way. It’s about putting your project tasks in the right order so everything makes sense and nothing gets stuck.

🎯 What is the Sequence Activities Process?

Think of Sequence Activities as creating a recipe for your project.

When you bake a cake, you can’t frost it before you bake it. You have steps:

1. Mix ingredients
2. Pour into pan
3. Bake
4. Cool
5. Frost

The Sequence Activities process takes your list of tasks and puts them in the right order.

📌 Simple Example

Building a treehouse:

• Can’t happen first: Paint the walls (walls don’t exist yet!)
• Must happen first: Build the floor (everything stands on it)
• Right order: Floor → Walls → Roof → Paint

What You Need (Inputs)

• Activity List: All the tasks you identified
• Milestone List: Big checkpoints
• Project Documents: Any info about dependencies

What You Get (Outputs)

• Project Schedule Network Diagram: A map showing how tasks connect
• Updated Documents: Any new dependencies discovered

🔗 The Precedence Diagramming Method (PDM)

PDM is your visual map of task connections. It’s the most popular way to show which tasks come before or after others.

🎨 How It Works

Imagine boxes connected by arrows:

graph TD
    A["Buy Lumber"] --> B["Cut Wood"]
    B --> C["Assemble Frame"]
    C --> D["Paint"]

Each box = one activity Each arrow = the connection (dependency)

The Rule

The arrow points FROM the task that must finish FIRST, TO the task that comes AFTER.

Real Example: Making a Sandwich

graph TD
    A["Get Bread"] --> B["Spread Butter"]
    B --> C["Add Filling"]
    C --> D["Close Sandwich"]

You can’t spread butter before you have bread!

🔄 Logical Relationships in PDM

There are 4 types of relationships between tasks. Think of them as 4 ways activities can connect.

1. Finish-to-Start (FS) — The Most Common! 🌟

Rule: Task A must FINISH before Task B can START.

Example: You must finish cooking dinner before you can start eating it.

graph LR
    A["Cook Dinner"] -->|FS| B["Eat Dinner"]

2. Start-to-Start (SS)

Rule: Task A must START before Task B can START.

They can run together, but B can’t begin until A begins.

Example: A band rehearsal — the drummer must start playing before the singer can start singing (they need the beat first!).

graph LR
    A["Drummer Starts"] -->|SS| B["Singer Starts"]

3. Finish-to-Finish (FF)

Rule: Task A must FINISH before Task B can FINISH.

They can both be happening, but B can’t end until A ends.

Example: Filming a movie scene and recording sound. Sound recording can’t finish until filming finishes.

graph LR
    A["Film Scene"] -->|FF| B["Record Sound"]

4. Start-to-Finish (SF) — The Rare One! 🦄

Rule: Task A must START before Task B can FINISH.

This is unusual. It’s like saying “the new shift must start before the old shift can finish.”

Example: The night security guard can’t go home until the day guard arrives.

graph LR
    A["Day Guard Arrives"] -->|SF| B["Night Guard Leaves"]

Quick Memory Trick 🧠

⏱️ Leads and Lags

Sometimes tasks don’t follow perfectly one after another. You need wiggle room.

🏃 Lead (Speed Up!)

A lead lets you start the next task early — before the previous one fully finishes.

Example:

• Task A: Paint the walls (takes 3 days)
• Task B: Install light fixtures

With a 1-day lead, you can start installing lights on day 3, even though painting isn’t 100% done. The wall where the light goes is already dry!

Paint Walls: [Day 1] [Day 2] [Day 3]
                           ↓ Lead = -1 day
Install Lights:        [Day 3] [Day 4]

Lead = Negative time (we subtract from the gap)

🐢 Lag (Slow Down!)

A lag forces you to wait before starting the next task.

Example:

• Task A: Pour concrete
• Task B: Build on top of concrete

Concrete needs 2 days to cure (dry and harden). Even though pouring is done, you must wait!

Pour Concrete: [Day 1]
                  ↓ Lag = +2 days
Build:                [Day 4] [Day 5]

Lag = Positive time (we add a waiting period)

Memory Helper 🎯

🏗️ Dependency Types

Not all connections between tasks are the same. Some are required by nature, others are your choice.

1. Mandatory Dependencies (Hard Logic) 🔒

These MUST happen in this order. Nature or rules demand it.

Example: You must dig a hole before you can plant a tree. There’s no other way.

Also called: Hard logic, hard dependencies

2. Discretionary Dependencies (Soft Logic) 🎨

These are your choice based on best practices or preferences. You could do it differently.

Example:

• You prefer to paint walls before installing furniture
• But you could install furniture first and paint around it

Also called: Preferred logic, soft logic

3. External Dependencies 🌍

These depend on someone or something outside your project.

Example:

• You can’t install the new software until the vendor delivers it
• You can’t start outdoor work until the weather clears

You can’t control external dependencies!

4. Internal Dependencies 🏠

These are within your project — between your own tasks.

Example: Your design team must finish mockups before your dev team can code.

Dependency Matrix 📊

🎛️ Dependency Management

Managing dependencies is like being a traffic controller. You need to:

1. Identify all dependencies (find all the connections)
2. Document them (write them down clearly)
3. Monitor them (watch for problems)
4. Adjust when needed (fix bottlenecks)

Best Practices ✨

1. Map Everything First Before starting, draw out your entire network. See ALL connections.

2. Question Discretionary Dependencies Ask: “Do we REALLY need to do A before B? Or is that just habit?”

3. Watch External Dependencies Closely You can’t control them, but you CAN plan for delays.

4. Use Buffers Wisely Add small lags where you know things might go wrong.

5. Review Regularly Dependencies can change! Review your network diagram often.

Warning Signs ⚠️

• Too many dependencies on one task: Bottleneck alert!
• Long chains of FS dependencies: Very risky — one delay affects everything
• Unclear dependencies: Document them NOW before confusion hits

🎬 Putting It All Together

Let’s build a simple project network for “Planning a Birthday Party”:

graph TD
    A["Choose Date"] --> B["Book Venue"]
    A --> C["Create Guest List"]
    B --> D["Send Invitations"]
    C --> D
    D --> E["Order Food"]
    D --> F["Buy Decorations"]
    E --> G["Party Day!"]
    F --> G

Dependencies explained:

• A→B: Can’t book venue until you know the date (FS, Mandatory)
• A→C: Need date to tell guests when (FS, Mandatory)
• D needs B and C: Can’t invite without venue and guest list (FS, Mandatory)
• E and F need D: Wait for RSVPs to know how much to order (FS, Discretionary)

🏆 Key Takeaways

1. Sequence Activities = Putting tasks in the right order
2. PDM = Boxes and arrows showing task connections
3. 4 Relationships: FS (most common), SS, FF, SF (rare)
4. Leads = Start early (negative time)
5. Lags = Forced waiting (positive time)
6. 4 Dependency Types: Mandatory, Discretionary, External, Internal
7. Dependency Management = Identify, document, monitor, adjust

Remember: A well-sequenced project is like a well-choreographed dance. Every step happens at the right moment, and the whole performance flows beautifully! 💃🕺

You’ve got this! Activity sequencing isn’t scary — it’s just putting your project puzzle pieces in order. 🧩✨