Parallel Execution and Handoffs

Introduction

Welcome back! We have reached the final lesson of our course. So far, you have learned how to turn a project specification into a technical plan, how to design atomic tasks, and how to build systems with multiple components. In this final section, we focus on efficiency . Now that you know how to break down work, you need to know how to organize those pieces to finish the project as quickly as possible. We will learn how to run tasks at the same time, how to pass work between tasks, and how to fix a plan when things go wrong. Practice Environment Note: These exercises use simplified Python classes to demonstrate parallel execution concepts. In production systems, you'd apply the same earliest-start scheduling and dependency analysis to real microservices, CI/CD pipelines, or distributed systems. The calculation methodology (critical paths, parallel opportunities) is universal.

Executing Tasks In Parallel

When we talk about parallel execution, we mean working on multiple tasks at the same time. In a professional setting, this might involve different developers working on different parts of a feature. Even if you are working alone, understanding parallelism helps you identify which parts of your project are independent. To run tasks in parallel, they must have no dependencies . A dependency is simply a requirement that one task must be finished before another can start. Imagine we are building a Comments feature. Here is a simplified task list: Task ID Task Name Dependencies Can Run Parallel? T001 Create Comment Database Model None No (Start here) T002 Create Comment Repository T001 Yes (with T003) T003 Create Comment Schema (API structure) T001 Yes (with T002) T004 Create Comment API Endpoints T002, T003 No In this example, T002 and T003 both need the database model (T001) to exist. However, the Repository (which communicates with the database) and the Schema (which defines how data looks in the API) do not need each other. By identifying these gaps, you reduce the calendar time of a project. While the total work hours remain the same, the project finishes sooner because work happens on two tracks simultaneously.

Task ID	Task Name	Dependencies	Can Run Parallel?
`T001`	Create Comment Database Model	None	No (Start here)
`T002`	Create Comment Repository	`T001`	Yes (with `T003`)
`T003`	Create Comment Schema (API structure)	`T001`	Yes (with `T002`)
`T004`	Create Comment API Endpoints	`T002`, `T003`	No

Understanding Earliest-Start Scheduling

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Visualizing Parallel Execution Strategy

Let's look at a more complex example: building a Real-Time Notification System. This system requires three independent components that can be built in parallel before integrating them together:

text

START (Time 0)
  │
  └─────────────────┬─────────────────┬─────────────────┐
                    │                 │                 │
              Track 1: WebSocket  Track 2: Redis   Track 3: Event
                 Connection         Pub/Sub        Publishing
                    │                 │                 │
                 [T001]            [T003]            [T005]
              Setup WebSocket    Setup Redis      Create Event
                 Handler          Client           Publisher
                (45 min)         (45 min)         (45 min)
              finish=45          finish=45        finish=45
                    │                 │                 │
                 [T002]            [T004]            [T006]
              Create Message    Implement         Define Event
               Broadcasting    Subscription       Schema
                (45 min)         (45 min)         (45 min)
              start=45          start=45         start=45
              finish=90         finish=90        finish=90
                    │                 │                 │
                    └─────────────────┴─────────────────┘
                                      │
                                 [T007-T008]
                              INTEGRATION PHASE
                           (Connect all components)
                              start=90 (after all tracks)
                              +45 min each = finish=180
                                      │
                                    DONE
                                 180 minutes total

START (Time 0)
  │
  └─────────────────┬─────────────────┬─────────────────┐
                    │                 │                 │
              Track 1: WebSocket  Track 2: Redis   Track 3: Event
                 Connection         Pub/Sub        Publishing
                    │                 │                 │
                 [T001]            [T003]            [T005]
              Setup WebSocket    Setup Redis      Create Event
                 Handler          Client           Publisher
                (45 min)         (45 min)         (45 min)
              finish=45          finish=45        finish=45
                    │                 │                 │
                 [T002]            [T004]            [T006]
              Create Message    Implement         Define Event
               Broadcasting    Subscription       Schema
                (45 min)         (45 min)         (45 min)
              start=45          start=45         start=45
              finish=90         finish=90        finish=90
                    │                 │                 │
                    └─────────────────┴─────────────────┘
                                      │
                                 [T007-T008]
                              INTEGRATION PHASE
                           (Connect all components)
                              start=90 (after all tracks)
                              +45 min each = finish=180
                                      │
                                    DONE
                                 180 minutes total

How This Works:

Track 1 (WebSocket): Tasks T001-T002 build the WebSocket connection layer independently.
Track 2 (Redis): Tasks T003-T004 set up the Redis messaging infrastructure independently.
Track 3 (Event Publishing): Tasks T005-T006 create the event structure independently.
Integration: Once all three tracks complete (at 90 min), tasks T007-T008 can begin.

Timeline Calculation:

Tracks 1, 2, 3 all complete at 90 minutes (running in parallel)
Integration starts at 90 minutes, completes at 180 minutes
Total: 180 minutes

If done sequentially: 45+45+45+45+45+45+45+45 = 360 minutes

Time saved: 50% through parallel execution!

Creating Seamless Task Handoffs

When tasks are split up, the biggest risk is that the parts will not fit together at the end. We prevent this by using explicit handoff instructions.

A handoff happens when one task relies on code created in a previous task. You must tell Claude exactly where that code is and how to use it. Let's look at an example where we need to build an AttachmentService that uses an S3Client created in a previous step.

First, let's look at the "existing" code created in a prior task (T003):

Python

# src/storage/s3_client.py

class S3Client:
    def __init__(self):
        self.storage = {}  # Mock storage for learning environment
    
    def upload(self, file_data, file_key):
        # Logic to upload to mock storage
        print(f"Uploading {file_key} to S3...")
        self.storage[file_key] = file_data
        return True

# src/storage/s3_client.py

class S3Client:
    def __init__(self):
        self.storage = {}  # Mock storage for learning environment
    
    def upload(self, file_data, file_key):
        # Logic to upload to mock storage
        print(f"Uploading {file_key} to S3...")
        self.storage[file_key] = file_data
        return True

This is our starting point. When we write the prompt or the acceptance criteria for the next task (T005), we should not simply say, "Build a service to save files." Instead, we provide a clear handoff:

text

Acceptance Criteria for T005:
1. Import and use S3Client from src/storage/s3_client.py.
2. Create an AttachmentService class.
3. Call the s3_client.upload(file, key) method within the service.

Acceptance Criteria for T005:
1. Import and use S3Client from src/storage/s3_client.py.
2. Create an AttachmentService class.
3. Call the s3_client.upload(file, key) method within the service.

Now, let's see how the code is built following that handoff:

Python

from src.storage.s3_client import S3Client

class AttachmentService:
    def __init__(self, db_repo, s3_client):
        # We initialize the client we were told about
        self.db_repo = db_repo
        self.s3_client = s3_client

    def save_attachment(self, file, filename, task_id):
        # We use the specific method name from the handoff
        s3_key = f"attachments/{task_id}/{filename}"
        self.s3_client.upload(file, s3_key)
        
        # Then save metadata to database
        attachment = {"filename": filename, "s3_key": s3_key, "task_id": task_id}
        return self.db_repo.create(attachment)

from src.storage.s3_client import S3Client

class AttachmentService:
    def __init__(self, db_repo, s3_client):
        # We initialize the client we were told about
        self.db_repo = db_repo
        self.s3_client = s3_client

    def save_attachment(self, file, filename, task_id):
        # We use the specific method name from the handoff
        s3_key = f"attachments/{task_id}/{filename}"
        self.s3_client.upload(file, s3_key)
        
        # Then save metadata to database
        attachment = {"filename": filename, "s3_key": s3_key, "task_id": task_id}
        return self.db_repo.create(attachment)

By being specific about the file path (src/storage/s3_client.py) and the method name (upload), we ensure the AI does not attempt to reinvent the storage logic or create a different, incompatible version of the client.

Introduction

Executing Tasks In Parallel

Understanding Earliest-Start Scheduling

Join the 1M+ learners on CodeSignal

Calculating Project Timeline with Earliest-Start Scheduling

Visualizing Parallel Execution Strategy

Creating Seamless Task Handoffs

Fixing Decomposition Anti-Patterns

Recovery And Refinement Strategies

Summary, Practice, And Course Wrap-Up