Using Layers for Waterfall Projects

Difficulty: Intermediate

Overview

Traditional project management methodologies like waterfall remain essential for many business contexts, especially when dealing with complex projects that require sequential phases, comprehensive planning upfront, and clear milestone-based governance. Waymaker's layer system provides the perfect structure for waterfall project management, enabling you to organize phases, stages, milestones, and tasks in a clear, hierarchical manner while maintaining visibility across the entire project timeline.

This comprehensive guide shows you how to set up and manage waterfall projects using Waymaker taskboards. Whether you're managing a website redesign, implementing an enterprise system, running a construction project, or executing a product launch, you'll learn how to structure your board for maximum clarity and control.

What You'll Learn

• How to structure waterfall boards with phases, stages, and milestones
• Setting up sequential project workflows and dependencies
• Creating and managing phase layers for major project segments
• Using stage sub-layers for detailed phase breakdowns
• Implementing milestone layers for gates and approval points
• Configuring task dependencies for waterfall execution
• Leveraging Gantt chart view for timeline visualization
• Tracking critical path and identifying schedule risks
• Managing phase gates and approval workflows
• Best practices for traditional project management in Waymaker

Prerequisites

• Understanding of waterfall/traditional project management methodology
• Familiarity with Waymaker layers (see Introduction to Layers)
• Knowledge of creating layers (see Creating and Managing Layers)
• Understanding of Stage and Milestone layer types (see Layer Types Explained)

Waterfall Board Setup

Waterfall projects succeed when you establish clear structure from the beginning. Your board architecture should reflect the sequential nature of waterfall delivery.

Recommended Waterfall Board Structure

The most effective waterfall board structure uses a three-level hierarchy:

Level 1 (Root): Phases (major project segments)
Level 2 (Child): Stages (detailed phase activities)
Level 3 (Special): Milestones (gates and approval points)
Tasks: Specific deliverables and work items

Example Structure:

Website Redesign Project
├── Phase 1: Discovery (Weeks 1-3)
│   ├── Stage: Stakeholder Interviews
│   │   ├── Task: Schedule interviews
│   │   ├── Task: Conduct CEO interview
│   │   ├── Task: Conduct stakeholder sessions
│   │   └── Task: Document findings
│   ├── Stage: Competitive Analysis
│   │   ├── Task: Identify competitors
│   │   ├── Task: Analyze competitor sites
│   │   └── Task: Document insights
│   ├── Stage: Requirements Gathering
│   │   ├── Task: Document functional requirements
│   │   ├── Task: Document technical requirements
│   │   └── Task: Document content requirements
│   └── Milestone: Requirements Sign-off (Week 3, Friday)
│
├── Phase 2: Design (Weeks 4-8)
│   ├── Stage: Information Architecture
│   │   ├── Task: Create sitemap
│   │   ├── Task: Define navigation structure
│   │   └── Task: Document content hierarchy
│   ├── Stage: Wireframes
│   │   ├── Task: Create homepage wireframe
│   │   ├── Task: Create interior page wireframes
│   │   └── Task: Conduct wireframe review
│   ├── Stage: Visual Design
│   │   ├── Task: Create design concepts
│   │   ├── Task: Design homepage
│   │   ├── Task: Design interior templates
│   │   └── Task: Create style guide
│   └── Milestone: Design Approval (Week 8, Friday)
│
├── Phase 3: Development (Weeks 9-16)
│   ├── Stage: Frontend Development
│   ├── Stage: Backend Development
│   ├── Stage: Content Migration
│   └── Milestone: Development Complete (Week 16)
│
├── Phase 4: Testing & QA (Weeks 17-18)
│   ├── Stage: Functional Testing
│   ├── Stage: Browser Testing
│   ├── Stage: Performance Testing
│   └── Milestone: QA Sign-off (Week 18)
│
└── Phase 5: Launch (Week 19)
    ├── Stage: Pre-Launch Preparation
    ├── Stage: Deployment
    ├── Stage: Post-Launch Monitoring
    └── Milestone: Go-Live (Week 19, Monday)

Step-by-Step: Creating Your Waterfall Board

Step 1: Create the Project Board

1. Navigate to Taskboards
2. Click "Create Taskboard"
3. Name: Your project name (e.g., "Website Redesign Project")
4. Type: Project (for full features)
5. Description: Project overview, objectives, and key dates
6. Due Date: Project completion date
7. Create the board

Step 2: Customize Workflow Sections

Waterfall sections typically differ from agile boards:

Recommended Sections:

• Not Started: Tasks scheduled but not yet begun
• In Progress: Tasks actively being worked
• Review: Tasks awaiting approval or review
• On Hold: Blocked or paused tasks
• Complete: Finished tasks (mark as complete)

Optional Sections:

• Planning: Pre-work and preparation
• Awaiting Approval: Tasks pending stakeholder sign-off
• Rework: Tasks requiring changes after review

To Customize:

1. Open Board Settings → Sections tab
2. Add/rename sections to match your workflow
3. Set "Complete" as completion status
4. Save changes

Step 3: Define Project Phases

Identify the major segments of your project. Most waterfall projects have 4-7 phases.

Common Waterfall Phases:

Software/Website Projects:

• Discovery → Design → Development → Testing → Deployment

Construction/Engineering:

• Planning → Design → Permitting → Construction → Commissioning

Business Transformation:

• Assessment → Strategy → Planning → Implementation → Optimization

Product Launch:

• Concept → Development → Testing → Marketing → Launch

Step 4: Create Phase Layers

For each major phase:

1. Open Layer Manager
2. Click "Add Layer"
3. Type: Stage (represents a phase)
4. Name: "Phase 1: Discovery"
5. Description: Phase objectives, deliverables, and success criteria
6. Dates: Exact start and end dates (critical for waterfall)
7. Color: Use consistent phase colors (e.g., Discovery = Blue)
8. Create layer

Repeat for each phase. Most projects have 4-7 phases.

Step 5: Create Stage Sub-layers

Under each phase, create detailed stages:

1. Select parent phase in Layer Manager
2. Click "Add Sub-layer"
3. Type: Stage
4. Name: "Stage: Stakeholder Interviews"
5. Description: Stage activities and deliverables
6. Dates: Stage timeline within phase dates
7. Color: Lighter shade of phase color
8. Create layer

Repeat for all stages within each phase.

Step 6: Create Milestone Layers

At the end of key phases, add milestones for gates and approvals:

1. Select parent phase in Layer Manager
2. Click "Add Sub-layer" (or root layer for project-level milestones)
3. Type: Milestone
4. Name: "Requirements Sign-off"
5. Description: Approval criteria and reviewers
6. Dates: Single date (milestone completion date)
7. Color: Gold/Yellow (#FBBF24)
8. Create layer

Milestones represent:

• Phase completions
• Approval gates
• Key deliverables
• Go/no-go decision points
• Project checkpoints

Your waterfall board is now structured and ready for detailed planning!

Creating Phases as Top-Level Layers

Phases are the backbone of waterfall project management, representing major segments of work that must be completed sequentially.

What Makes a Good Phase?

Sequential: Must follow a logical order (can't design before requirements)

Complete: Each phase produces specific, verifiable deliverables

Distinct: Clear boundaries between phases

Time-Bound: Fixed start and end dates

Gate-Driven: Ends with approval or milestone before next phase begins

Phase Creation Process

Step 1: Identify Project Phases

Based on your project type, identify the major phases:

Website/Software Project Phases:

1. Discovery/Requirements: Understand needs and define scope
2. Design: Create user experience and visual design
3. Development: Build the solution
4. Testing/QA: Validate functionality and quality
5. Deployment/Launch: Go live
6. Warranty/Support: Post-launch stabilization

Construction/Physical Project Phases:

1. Feasibility Study: Assess viability
2. Design: Architectural and engineering plans
3. Permitting: Regulatory approvals
4. Procurement: Materials and contracts
5. Construction: Build phase
6. Commissioning: Testing and handover

Business Process Project Phases:

1. Current State Assessment: Understand as-is
2. Future State Design: Define to-be
3. Gap Analysis: Identify changes needed
4. Implementation Planning: Detailed roadmap
5. Execution: Make changes
6. Optimization: Refine and improve

Step 2: Write Phase Description

A complete phase description includes:

## Phase 2: Design

### Phase Objectives
Create comprehensive design deliverables including information architecture,
wireframes, and visual design for the new website, ensuring alignment with
brand guidelines and user experience best practices.

### Key Deliverables
- Sitemap and navigation structure
- Wireframes for all page templates (12 templates)
- Visual design mockups (homepage + 5 interior pages)
- Style guide documenting colors, typography, components
- Design asset library for development team

### Success Criteria
- [ ] All wireframes reviewed and approved by stakeholders
- [ ] Visual design aligns with brand guidelines
- [ ] Accessibility requirements incorporated (WCAG 2.1 AA)
- [ ] Responsive design for mobile, tablet, desktop
- [ ] Client sign-off on final designs

### Duration
5 weeks (Weeks 4-8)

### Resources
- Lead Designer: Sarah Johnson
- UX Designer: Michael Chen
- Brand Manager: Emily Rodriguez
- Budget: $25,000

### Dependencies
- Requires completion of Phase 1: Discovery
- Requirements document must be approved
- Brand guidelines must be available

### Risks
- Risk: Design iterations exceed timeline → Mitigation: Time-box revisions to 2 rounds
- Risk: Stakeholder disagreement on direction → Mitigation: Conduct design workshop in Week 4

Step 3: Create Phase Layer in Waymaker

1. Open Layer Manager
2. Add Layer → Type: Stage (used for phases)
3. Name: "Phase 2: Design"
4. Description: Paste your phase description
5. Start Date: Nov 1, 2025
6. End Date: Dec 5, 2025
7. Color: Blue (#3B82F6) or phase-specific color
8. Create

Step 4: Define Phase Stages

Break the phase into logical stages (detailed activities within the phase):

Phase 2: Design Stages:

• Stage 1: Information Architecture (Week 4)
• Stage 2: Wireframes (Weeks 5-6)
• Stage 3: Visual Design (Weeks 7-8)

Create these as sub-layers under the phase.

Phase Naming Best Practices

Good Phase Names:

• ✅ "Phase 1: Discovery & Requirements"
• ✅ "Phase 2: Design"
• ✅ "Phase 3: Development"
• ✅ "Planning Phase (Weeks 1-4)"
• ✅ "Pre-Production Phase"

Poor Phase Names:

• ❌ "Phase A" (not descriptive)
• ❌ "First Part" (too vague)
• ❌ "Step 1" (confusing with tasks)
• ❌ "Beginning" (not specific)

Naming Pattern: Phase [Number]: [Descriptive Name] or [Name] Phase (Dates)

Sequential Phase Dependencies

Waterfall phases typically follow strict sequences. Configure this using dates and dependencies:

Example Sequence:

Phase 1: Discovery (Oct 1 - Oct 21)
   ↓ (depends on completion)
Phase 2: Design (Oct 22 - Nov 26)
   ↓ (depends on completion)
Phase 3: Development (Nov 27 - Jan 22)
   ↓ (depends on completion)
Phase 4: Testing (Jan 23 - Feb 6)
   ↓ (depends on completion)
Phase 5: Launch (Feb 7 - Feb 14)

Ensure:

• Phase 2 start date = Phase 1 end date + 1 day
• No gaps (unless intentional buffer)
• No overlaps (unless phases can run in parallel)

Creating Stages as Sub-layers

Stages represent detailed activities within a phase. They provide granular organization and help teams understand specific work to be done.

What Makes a Good Stage?

Focused: Covers a specific type of work within the phase

Sized Appropriately: Typically 1-3 weeks (not too small or large)

Deliverable-Oriented: Produces specific outputs

Team-Aligned: Often aligned with team responsibilities

Trackable: Progress can be clearly measured

Stage Creation Process

Step 1: Decompose Phase into Activities

For each phase, identify the major activities:

Example: Phase 2 (Design) Activities:

1. Information Architecture (define structure)
2. Wireframing (create layouts)
3. Visual Design (apply branding)
4. Design Documentation (create guides)

Step 2: Create Stage Layers

For each activity:

1. Open Layer Manager
2. Select parent phase
3. Click "Add Sub-layer"
4. Type: Stage
5. Name: "Stage: Wireframes"
6. Description: Stage activities and deliverables
7. Dates: Nov 8 - Nov 19, 2025 (within parent phase dates)
8. Color: Lighter shade of phase color
9. Create layer

Step 3: Add Stage Details

## Stage: Wireframes

### Stage Goal
Create low-fidelity wireframes for all website page templates, focusing
on layout, content hierarchy, and user flow without visual design.

### Activities
1. Review information architecture
2. Sketch initial concepts
3. Create digital wireframes in Figma
4. Review with UX team
5. Present to stakeholders
6. Incorporate feedback
7. Finalize wireframes

### Deliverables
- Homepage wireframe
- Product page wireframe
- About page wireframe
- Contact page wireframe
- Blog page wireframe
- (12 total page templates)

### Team
- Lead: Michael Chen (UX Designer)
- Support: Sarah Johnson (reviewing)

### Duration
2 weeks (Weeks 5-6 of project)

### Success Criteria
- [ ] All 12 templates wireframed
- [ ] Stakeholder review completed
- [ ] Feedback incorporated
- [ ] Ready for visual design phase

Stage Naming Best Practices

Good Stage Names:

• ✅ "Stage: Information Architecture"
• ✅ "Stage: Stakeholder Interviews"
• ✅ "Stage: Frontend Development"
• ✅ "Requirements Gathering Stage"

Poor Stage Names:

• ❌ "Stage 1" (not descriptive)
• ❌ "Work" (too vague)
• ❌ "Tasks" (confusing with task level)
• ❌ "Part A" (not meaningful)

Naming Pattern: Stage: [Descriptive Activity Name]

Organizing Stages Within Phases

Recommended Structure:

Each phase should have 2-5 stages. Too many stages creates overhead; too few lacks detail.

Example Breakdown:

Phase 3: Development (8 weeks)

├── Stage: Development Environment Setup (Week 1)
├── Stage: Frontend Development (Weeks 2-4)
├── Stage: Backend Development (Weeks 2-5)
├── Stage: Content Management System (Weeks 6-7)
└── Stage: Integration & Testing (Week 8)

Note: Stages can overlap (Frontend and Backend run in parallel).

Parallel vs Sequential Stages

Sequential Stages (one after another):

Stage: Requirements Gathering (Weeks 1-2)
   ↓
Stage: Requirements Documentation (Week 3)
   ↓
Stage: Requirements Approval (Week 4)

Parallel Stages (concurrent work):

Phase: Development
├── Stage: Frontend Development (Weeks 1-4) ─┐
└── Stage: Backend Development (Weeks 1-5) ──┤ (run simultaneously)

Use task dependencies to manage both patterns effectively.

Milestones for Gates and Approvals

Milestones are critical checkpoints in waterfall projects, representing approval points, deliverables, or go/no-go decisions.

What Are Project Milestones?

Definition: A milestone is a significant point in the project timeline, typically marking completion of a phase or delivery of a major deliverable.

Characteristics:

• Zero duration (a point in time, not a period)
• No resources assigned (it's a checkpoint, not work)
• Often requires approval or sign-off
• Gates next phase (phase can't start until milestone achieved)

Types of Milestones

Phase Completion Milestones:

• "Discovery Complete"
• "Design Approved"
• "Development Done"
• "Testing Passed"

Approval Gate Milestones:

• "Requirements Sign-off"
• "Budget Approval"
• "Executive Review Complete"
• "Legal Clearance Obtained"

Deliverable Milestones:

• "Prototype Delivered"
• "Beta Release"
• "User Acceptance Testing Complete"
• "Training Materials Delivered"

Decision Point Milestones:

• "Go/No-Go Decision"
• "Technology Selection Complete"
• "Vendor Selected"
• "Pivot or Proceed Decision"

External Milestones:

• "RFP Response Due"
• "Contract Signed"
• "Regulatory Approval Received"
• "Third-Party Integration Complete"

Creating Milestone Layers

Step 1: Identify Required Milestones

Review your project plan and identify:

• End of each major phase
• Key approval points
• Critical deliverables
• External dependencies
• Decision gates

Step 2: Create Milestone Layer

1. Open Layer Manager
2. Select parent phase (or root for project-level milestones)
3. Click "Add Sub-layer"
4. Type: Milestone
5. Name: "Requirements Sign-off"
6. Description: Approval criteria and process
7. Date: Single date (e.g., Oct 21, 2025)
8. Color: Gold (#FBBF24) or consistent milestone color
9. Create layer

Step 3: Define Approval Criteria

## Milestone: Requirements Sign-off

### Purpose
Formal approval of requirements document, confirming scope and
enabling design phase to begin.

### Deliverable
- Requirements Document (final version)
- Scope statement
- Acceptance criteria
- Project constraints and assumptions

### Approval Criteria
- [ ] Requirements document reviewed by all stakeholders
- [ ] Functional requirements complete and agreed
- [ ] Technical requirements documented
- [ ] Budget confirmed and approved
- [ ] Timeline validated
- [ ] Risks identified and documented
- [ ] Change control process agreed

### Approvers
- Project Sponsor: John Smith
- Business Owner: Sarah Johnson
- Technical Lead: Michael Chen
- Legal: Emily Rodriguez

### Approval Process
1. Circulate requirements document (5 business days)
2. Conduct approval meeting (Oct 20)
3. Obtain sign-offs (Oct 21)
4. Archive approved version

### Milestone Date
October 21, 2025 (Friday)

### Next Phase Dependency
Design phase cannot begin until this milestone is achieved.

Milestone as Tasks vs Layers

Option 1: Milestone as Layer (Recommended for major gates)

• Use layer type: Milestone
• Represents phase completion or major approval
• Visible in layer hierarchy
• Can contain approval tasks beneath it

Option 2: Milestone as Task (For smaller checkpoints)

• Create task with Type: Milestone
• For internal team checkpoints
• Less prominent than layer milestones
• Useful for deliverable submissions

Recommendation: Use milestone layers for formal approvals and phase gates. Use milestone tasks for smaller internal checkpoints.

Phase Gates and Approval Workflows

Phase Gate Process:

1. Pre-Gate Preparation (1 week before):

   • Compile deliverables
   • Prepare presentation
   • Distribute materials to approvers

2. Gate Review Meeting:

   • Present phase results
   • Demonstrate deliverables
   • Address questions and concerns
   • Document decisions

3. Approval Decision:

   • Go: Proceed to next phase
   • Conditional Go: Proceed with specific conditions
   • No-Go: Resolve issues before proceeding

4. Post-Gate Actions:

   • Document approvals
   • Archive phase deliverables
   • Brief next phase team
   • Update project schedule

Track in Waymaker:

• Create tasks under milestone layer for approval activities
• Use checklist for approval criteria
• Comment with approval decisions
• Move to "Complete" when approved

Sequential Task Dependencies

Waterfall projects are defined by their sequential dependencies—certain work can't begin until other work completes.

Understanding Dependency Types

Finish-to-Start (FS): Task B starts when Task A finishes

• Example: Development starts when Design finishes
• Most common in waterfall projects
• Use case: Sequential phases

Start-to-Start (SS): Task B starts when Task A starts

• Example: Testing planning starts when Development starts
• Use case: Parallel preparation work

Finish-to-Finish (FF): Task B finishes when Task A finishes

• Example: Documentation finishes when Development finishes
• Use case: Supporting deliverables

Start-to-Finish (SF): Task B finishes when Task A starts

• Example: Rarely used in waterfall
• Use case: Handoff scenarios (old system shuts down when new system launches)

Creating Task Dependencies

Step 1: Identify Dependent Tasks

Map out your project flow:

Requirements Gathering
   ↓ (FS: must finish first)
Requirements Approval
   ↓ (FS: must finish first)
Design Concept Creation
   ↓ (FS: must finish first)
Design Refinement
   ↓ (FS: must finish first)
Final Design Approval
   ↓ (FS: must finish first)
Development Begins

Step 2: Add Dependencies in Waymaker

1. Open the dependent task (the one that must wait)
2. Navigate to Dependencies section
3. Click "Add Dependency"
4. Select predecessor task (the one that must complete first)
5. Choose dependency type (typically Finish-to-Start for waterfall)
6. Set lag time if needed (e.g., 2 days between approval and next phase)
7. Save dependency

Step 3: Validate Dependencies

Check for:

• Circular dependencies (A depends on B, B depends on A) → Fix immediately
• Missing dependencies (work that can't actually start yet) → Add dependency
• Unnecessary dependencies (work that could run in parallel) → Remove to speed up project

Phase-Level Dependencies

While individual tasks have dependencies, you can also create phase-level dependencies:

Example:

Phase 1: Discovery (Oct 1-21)
Phase 2: Design (Oct 22 - Nov 26) ← Depends on Phase 1 completion
Phase 3: Development (Nov 27 - Jan 22) ← Depends on Phase 2 completion

Implement by:

1. Setting phase dates sequentially (no gaps or overlaps unless intentional)
2. Creating milestone tasks for phase completions
3. Adding task dependencies from last task of Phase 1 to first task of Phase 2

Gantt Chart View for Timeline Visualization

The Gantt chart is the quintessential waterfall project visualization, showing tasks, durations, dependencies, and timeline all at once.

Accessing Gantt View

1. Navigate to your taskboard
2. Click the view switcher at top of board
3. Select Gantt Chart view
4. Board displays in timeline format

Reading the Gantt Chart

Horizontal Axis: Timeline (days, weeks, or months)

Vertical Axis: Tasks and layers (hierarchical)

Task Bars:

• Length represents duration (start date → due date)
• Position shows when task occurs
• Color indicates layer or priority

Dependency Lines:

• Arrows connect dependent tasks
• Show task relationships visually
• Help identify critical path

Milestones:

• Diamond shapes on timeline
• Represent zero-duration checkpoints
• Often mark phase completions

Today Marker:

• Vertical line showing current date
• Helps identify if tasks are on schedule

Using Gantt View for Waterfall Projects

During Planning:

1. Switch to Gantt view
2. Review overall project timeline
3. Identify scheduling conflicts
4. Validate dependencies are correct
5. Ensure no gaps between phases
6. Confirm milestones align with phase completions

During Execution:

1. Monitor progress against timeline
2. Identify tasks running behind
3. Assess impact of delays on dependent tasks
4. Update task dates as needed
5. Track critical path (see next section)

For Reporting:

1. Export Gantt view (future feature)
2. Share timeline with stakeholders
3. Show overall project status
4. Highlight upcoming milestones
5. Demonstrate schedule adherence

Gantt View Controls

Zoom:

• Day view: Detailed daily schedule
• Week view: Standard project view
• Month view: High-level overview

Filter:

• Show specific layers (e.g., only Phase 2)
• Show specific assignees
• Show tasks with dependencies only

Expand/Collapse:

• Collapse phases to see high-level timeline
• Expand phases to see detailed tasks

Critical Path Analysis

The critical path is the sequence of tasks that determines the shortest time to complete the project. Any delay on the critical path delays the entire project.

Understanding Critical Path

Definition: The longest path through the project network, considering task dependencies.

Why It Matters:

• Tasks on critical path have zero slack (no delay tolerance)
• Delays to critical path tasks delay the entire project
• Non-critical path tasks have slack (can be delayed without impacting project end date)
• Focus resources on critical path to keep project on schedule

Identifying Critical Path

Manual Method:

1. List all task sequences from project start to end:

   • Path A: Requirements → Design → Development → Testing → Launch
   • Path B: Requirements → Content Strategy → Content Creation → Content Review → Launch

2. Calculate duration for each path:

   • Path A: 3 weeks + 5 weeks + 8 weeks + 2 weeks + 1 week = 19 weeks
   • Path B: 3 weeks + 1 week + 4 weeks + 1 week + 1 week = 10 weeks

3. Identify longest path:

   • Path A (19 weeks) is the critical path
   • Path B (10 weeks) has 9 weeks of slack

In Gantt View (Future Feature):

• Critical path tasks highlighted (e.g., red color)
• Non-critical tasks shown in standard color
• Slack time displayed for non-critical tasks

Managing the Critical Path

Strategies:

Shorten Critical Path:

• Fast-track: Overlap sequential activities (with risk)
• Crash: Add resources to critical tasks
• Reduce scope: Remove tasks from critical path

Protect Critical Path:

• Assign best resources to critical tasks
• Monitor critical tasks daily
• Escalate issues immediately
• Build buffer time at end of critical path tasks

Shift Work Off Critical Path:

• Move resources from non-critical to critical tasks
• Delay non-critical tasks if resource constrained
• Focus on critical path completion

Monitor Critical Path Changes:

• Critical path can change as project progresses
• Delays to non-critical tasks can make them critical
• Regular critical path review (weekly)

Example Critical Path Scenario

Original Plan:

Critical Path: Requirements (3w) → Design (5w) → Development (8w) → Testing (2w) → Launch (1w)
Total: 19 weeks

Issue: Design takes 7 weeks (2 weeks over)

New Critical Path: Requirements (3w) → Design (7w) → Development (8w) → Testing (2w) → Launch (1w)
Total: 21 weeks → Project delayed 2 weeks

Solution: Crash Development:

Add developers to shorten Development to 6 weeks
New Critical Path: Requirements (3w) → Design (7w) → Development (6w) → Testing (2w) → Launch (1w)
Total: 19 weeks → Project back on schedule

Phase Gates and Approval Workflows

Phase gates are formal approval points between project phases, ensuring quality and alignment before proceeding.

What Is a Phase Gate?

Definition: A structured decision point between project phases where stakeholders review deliverables and approve (or reject) progression to the next phase.

Purpose:

• Ensure phase objectives achieved
• Validate deliverables meet quality standards
• Confirm budget and schedule alignment
• Obtain stakeholder buy-in
• Identify risks before proceeding

Stage-Gate Process

Common Gate Points:

• Gate 1: After Discovery → Approve requirements, scope, budget
• Gate 2: After Design → Approve designs, technical approach
• Gate 3: After Development → Approve working solution, quality
• Gate 4: After Testing → Approve for production deployment
• Gate 5: After Launch → Approve for handoff to operations

Implementing Phase Gates in Waymaker

Step 1: Create Gate Milestone

1. At end of each phase, create milestone layer
2. Name: "[Phase Name] Gate" or "[Phase Name] Approval"
3. Date: Last day of phase
4. Description: Gate criteria and approval process

Step 2: Define Gate Criteria

## Gate 2: Design Approval

### Gate Purpose
Validate design deliverables meet requirements and obtain approval
to proceed to development phase.

### Deliverables for Review
- [ ] Complete sitemap
- [ ] All wireframes (12 templates)
- [ ] Visual design mockups (6 pages)
- [ ] Style guide
- [ ] Design system documentation
- [ ] Responsive breakpoints defined

### Quality Criteria
- [ ] Designs align with brand guidelines
- [ ] Accessibility standards met (WCAG 2.1 AA)
- [ ] All requirements addressed in design
- [ ] Technical feasibility confirmed
- [ ] Budget estimates validated

### Approval Requirements
- Design Lead: Approved ✅
- Project Sponsor: Approved ✅
- Business Owner: Approved ✅
- Technical Lead: Approved ✅

### Gate Decision
- ✅ **GO**: Proceed to Development Phase
- ⚠️ **CONDITIONAL GO**: Proceed with specific conditions
- ❌ **NO-GO**: Resolve issues before proceeding

### Gate Date
November 26, 2025

Step 3: Create Gate Tasks

Under the gate milestone, create tasks for the approval process:

Tasks:

• "Compile design deliverables" (Due: 1 week before gate)
• "Distribute materials to approvers" (Due: 3 days before gate)
• "Conduct gate review meeting" (Due: Gate date)
• "Obtain formal approvals" (Due: Gate date)
• "Document gate decision" (Due: 1 day after gate)

Step 4: Execute Gate Review

Pre-Gate (1 week before):

• Verify all deliverables complete
• Prepare presentation
• Send materials to approvers

Gate Meeting:

• Present phase results
• Demonstrate deliverables
• Answer questions
• Address concerns

Post-Gate:

• Document decision (Go/Conditional/No-Go)
• Log approvals in task comments
• Update project plan based on decision
• Brief next phase team if Go decision

Conditional Approval

Sometimes gates result in "Conditional Go":

Example:

Gate Decision: CONDITIONAL GO

Conditions:
1. Revise homepage design based on feedback (Due: Dec 1)
2. Obtain legal review of disclaimers (Due: Dec 3)
3. Development can begin on approved pages while revisions in progress

Next Gate Review: December 5 (mini-gate to confirm conditions met)

Track conditional items as tasks in the milestone layer.

Recommended Waterfall Structure: Website Redesign Example

Here's a complete, production-ready waterfall board structure for a website redesign project:

Complete Structure

Website Redesign Project
Due: March 31, 2026
│
├── Phase 1: Discovery & Requirements (Oct 1-21, 2025)
│   ├── Stage: Stakeholder Interviews (Oct 1-7)
│   │   ├── Task: Schedule interviews
│   │   ├── Task: Conduct CEO interview
│   │   ├── Task: Conduct marketing interview
│   │   ├── Task: Conduct sales interview
│   │   └── Task: Document findings
│   │
│   ├── Stage: Competitive Analysis (Oct 8-14)
│   │   ├── Task: Identify top 5 competitors
│   │   ├── Task: Analyze competitor websites
│   │   ├── Task: Document strengths/weaknesses
│   │   └── Task: Create competitive matrix
│   │
│   ├── Stage: Requirements Gathering (Oct 15-19)
│   │   ├── Task: Document functional requirements
│   │   ├── Task: Document technical requirements
│   │   ├── Task: Document content requirements
│   │   ├── Task: Define success metrics
│   │   └── Task: Create requirements document
│   │
│   └── Milestone: Requirements Sign-off (Oct 21)
│       ├── Task: Requirements review meeting
│       └── Task: Obtain stakeholder approvals
│
├── Phase 2: Design (Oct 22 - Nov 26, 2025)
│   ├── Stage: Information Architecture (Oct 22-28)
│   │   ├── Task: Create sitemap
│   │   ├── Task: Define navigation structure
│   │   ├── Task: Document content hierarchy
│   │   └── Task: IA review and approval
│   │
│   ├── Stage: Wireframes (Nov 1-12)
│   │   ├── Task: Create homepage wireframe
│   │   ├── Task: Create product page wireframes
│   │   ├── Task: Create about/contact wireframes
│   │   ├── Task: Create blog wireframes
│   │   ├── Task: Wireframe review meeting
│   │   └── Task: Incorporate feedback
│   │
│   ├── Stage: Visual Design (Nov 13-26)
│   │   ├── Task: Create design concepts (3 options)
│   │   ├── Task: Concept review and selection
│   │   ├── Task: Design homepage
│   │   ├── Task: Design interior templates
│   │   ├── Task: Create component library
│   │   ├── Task: Create style guide
│   │   └── Task: Final design review
│   │
│   └── Milestone: Design Approval (Nov 26)
│       ├── Task: Design presentation to stakeholders
│       └── Task: Obtain design sign-off
│
├── Phase 3: Development (Nov 27, 2025 - Jan 22, 2026)
│   ├── Stage: Environment Setup (Nov 27 - Dec 3)
│   │   ├── Task: Set up development environment
│   │   ├── Task: Configure staging server
│   │   ├── Task: Set up version control
│   │   └── Task: Configure CMS
│   │
│   ├── Stage: Frontend Development (Dec 4-31)
│   │   ├── Task: Build homepage template
│   │   ├── Task: Build product page template
│   │   ├── Task: Build interior page templates
│   │   ├── Task: Implement navigation
│   │   ├── Task: Implement responsive design
│   │   └── Task: Browser compatibility testing
│   │
│   ├── Stage: Backend Development (Dec 4 - Jan 14)
│   │   ├── Task: Database design
│   │   ├── Task: API development
│   │   ├── Task: CMS integration
│   │   ├── Task: Form functionality
│   │   └── Task: Search functionality
│   │
│   ├── Stage: Content Migration (Jan 7-21)
│   │   ├── Task: Export content from old site
│   │   ├── Task: Clean and organize content
│   │   ├── Task: Import content to new CMS
│   │   ├── Task: Format and optimize content
│   │   └── Task: Verify content accuracy
│   │
│   └── Milestone: Development Complete (Jan 22)
│       └── Task: Code review and merge to staging
│
├── Phase 4: Testing & QA (Jan 23 - Feb 6, 2026)
│   ├── Stage: Functional Testing (Jan 23-27)
│   │   ├── Task: Test all forms
│   │   ├── Task: Test navigation
│   │   ├── Task: Test search
│   │   ├── Task: Test content display
│   │   └── Task: Document bugs
│   │
│   ├── Stage: Browser & Device Testing (Jan 28-30)
│   │   ├── Task: Test Chrome/Edge/Safari/Firefox
│   │   ├── Task: Test mobile devices (iOS/Android)
│   │   ├── Task: Test tablet devices
│   │   └── Task: Fix compatibility issues
│   │
│   ├── Stage: Performance Testing (Feb 1-3)
│   │   ├── Task: Page load speed testing
│   │   ├── Task: Optimize images
│   │   ├── Task: Optimize code
│   │   └── Task: Verify performance targets met
│   │
│   ├── Stage: User Acceptance Testing (Feb 4-6)
│   │   ├── Task: Conduct UAT with stakeholders
│   │   ├── Task: Address UAT feedback
│   │   └── Task: Final UAT sign-off
│   │
│   └── Milestone: QA Sign-off (Feb 6)
│       └── Task: Obtain QA and UAT approvals
│
└── Phase 5: Launch (Feb 7-14, 2026)
    ├── Stage: Pre-Launch Preparation (Feb 7-12)
    │   ├── Task: Backup old website
    │   ├── Task: DNS configuration
    │   ├── Task: SSL certificate setup
    │   ├── Task: Analytics setup
    │   ├── Task: Create launch checklist
    │   └── Task: Final stakeholder walkthrough
    │
    ├── Stage: Deployment (Feb 13)
    │   ├── Task: Deploy to production server
    │   ├── Task: Verify deployment successful
    │   ├── Task: Update DNS records
    │   └── Task: Monitor for issues
    │
    ├── Milestone: Go-Live (Feb 13, 9:00 AM)
    │
    └── Stage: Post-Launch Monitoring (Feb 14)
        ├── Task: Monitor site performance
        ├── Task: Monitor error logs
        ├── Task: Address any critical issues
        └── Task: Collect user feedback

Section Structure

Sections (Kanban columns):
├── Not Started (tasks scheduled but not yet begun)
├── In Progress (actively being worked)
├── Review (awaiting review or approval)
├── On Hold (blocked or paused)
└── Complete (finished and approved)

Timeline Summary

Total Project Duration: 19 weeks (Oct 1, 2025 - Feb 14, 2026)

Phase Durations:
├── Discovery: 3 weeks
├── Design: 5 weeks
├── Development: 8 weeks
├── Testing & QA: 2 weeks
└── Launch: 1 week

Critical Path: Discovery → Design → Development → Testing → Launch

Waterfall Best Practices with Waymaker Layers

Layer Organization

Phase Guidelines:

• 4-7 phases for most projects
• Each phase has clear deliverables and approval gates
• Sequential dates with no gaps (unless buffer time is intentional)
• Consistent naming: "Phase [N]: [Name]"
• Use same color scheme across projects for phase types

Stage Guidelines:

• 2-5 stages per phase (not too many, not too few)
• Each stage represents 1-3 weeks of work
• Stage dates must fall within parent phase dates
• Use lighter shade of phase color
• Stage deliverables should be clearly defined

Milestone Guidelines:

• At least one milestone per phase (at phase completion)
• Additional milestones for major deliverables or decisions
• Single date (not a range)
• Gold/yellow color for visual distinction
• Clear approval criteria in milestone description

Dependency Management

Best Practices:

• Map all dependencies during planning phase
• Use Finish-to-Start (FS) for most waterfall dependencies
• Add lag time for approval periods (e.g., 2-3 days after completion)
• Review dependencies weekly for accuracy
• Update dependencies when project changes occur

Avoid:

• Circular dependencies (A depends on B, B depends on A)
• Missing dependencies (work that can't actually start yet)
• Over-constraining (adding dependencies unnecessarily)

Timeline Management

Scheduling Best Practices:

• Set realistic phase durations based on similar projects
• Include buffer time (10-15% of phase duration)
• Account for holidays and team time off
• Leave gaps between phases for approval periods
• Use Gantt view to validate timeline logic

Date Management:

• Set exact dates on all phases, stages, and milestones
• Update dates when scope or timeline changes
• Communicate date changes to stakeholders immediately
• Track baseline vs. actual dates for learning

Progress Tracking

Monitor:

• Phase completion percentage
• Milestone achievement rate
• Tasks on critical path
• Tasks behind schedule
• Upcoming approval gates

Update:

• Task status daily
• Phase progress weekly
• Stakeholder reports weekly/bi-weekly
• Timeline adjustments as needed

Communication

Stakeholder Updates:

• Weekly status reports (use List view or dashboard)
• Phase completion announcements
• Milestone achievement notifications
• Issue escalation for critical path delays

Team Communication:

• Daily task updates
• Blockers raised immediately
• Dependency changes communicated
• Resource needs identified early

Tips & Best Practices

• Front-Load Planning: Invest time in detailed planning upfront to prevent rework
• Clear Phase Boundaries: Define exactly what "done" means for each phase
• Rigorous Approval Gates: Don't skip gates; they prevent scope creep and quality issues
• Detailed Dependencies: Map all task dependencies to understand critical path
• Regular Gantt Review: Use Gantt view weekly to monitor timeline and dependencies
• Milestone Discipline: Treat milestones as hard checkpoints, not suggestions
• Buffer Time: Add 10-15% buffer to phase estimates for unknowns
• Change Control: Implement formal change request process for scope changes
• Document Everything: Capture decisions, approvals, and rationale in task comments
• Monitor Critical Path: Focus resources on critical path tasks to keep project on schedule

Common Mistakes to Avoid

• Skipping Discovery: Starting design or development without complete requirements
• Vague Phase Definitions: Not clearly defining what each phase delivers
• Overlapping Phases: Starting next phase before previous phase approved (unless intentional fast-tracking)
• Missing Dependencies: Not identifying that Task B can't start until Task A completes
• Ignoring Critical Path: Treating all tasks as equally important
• Inadequate Gate Criteria: Having approval gates without clear criteria
• No Buffer Time: Creating schedules with zero slack (guarantees delays)
• Changing Scope Mid-Phase: Adding work without adjusting timeline or budget
• Weak Approvals: Moving forward without proper stakeholder sign-off
• Poor Documentation: Not documenting decisions, leading to repeated discussions

Related Articles

• Introduction to Layers - Layer fundamentals
• Creating and Managing Layers - Layer creation guide
• Layer Types Explained - Stage and Milestone details
• Using Layers for Agile Projects - Agile alternative
• Waterfall/Traditional PM with Taskboards - Complete waterfall methodology guide
• Task Dependencies and Critical Path - Dependency management
• Gantt Chart View - Timeline visualization
• Layer Progress Tracking - Monitoring phase progress

Need More Help?

If you have questions about setting up waterfall workflows, phase planning, managing dependencies, or using layers for traditional project management, please contact support or visit our community forums. Our team can help you design the perfect waterfall structure for your project.