Introduction to Layers

Difficulty: Beginner

Overview

Layers are one of the most powerful organizational features in Waymaker taskboards, providing a flexible way to group and structure your tasks hierarchically. Whether you're managing a complex software development project, coordinating a marketing campaign, or overseeing a construction project, layers help you organize work into meaningful containers that reflect how your team thinks about the project.

This article introduces the concept of layers, explains how they work, and helps you understand when and how to use them effectively in your taskboards.

What You'll Learn

• What layers are and how they provide hierarchical organization
• The difference between layers and sections in your taskboard
• Different layer types (Epic, Sprint, Stage, Milestone, Custom) and their purposes
• How layers support both agile and waterfall project methodologies
• When to use layers versus keeping a flat task structure
• How layer hierarchy works with parent and child layers

Prerequisites

• A Waymaker account with access to taskboards
• Basic understanding of taskboards and task management
• Familiarity with creating and managing tasks

What Are Layers?

Layers are organizational containers that help you group related tasks together in a hierarchical structure. Think of them as flexible folders or categories that give your taskboard depth and structure beyond the standard workflow sections (like "To Do" and "In Progress").

The Purpose of Layers

Without layers, all your tasks exist in a flat list within your workflow sections. This works perfectly for simple projects or small task lists. But as projects grow more complex, you need a way to organize tasks into meaningful groups. That's where layers come in.

Layers allow you to:

• Group related tasks into logical containers (like features, phases, or timeframes)
• Create hierarchy by nesting layers within other layers
• Filter your view to focus on specific areas of work
• Track progress at different levels of your project
• Organize by methodology whether you work in agile sprints or waterfall phases
• Assign ownership at the layer level, not just individual tasks
• Set timeframes for groups of related work

Real-World Example

Imagine you're building a new website. Without layers, you'd have dozens of tasks all jumbled together. With layers, you can organize them like this:

Website Redesign Project
├── Discovery Phase
│   ├── Stakeholder interviews
│   ├── Competitive analysis
│   └── Requirements documentation
├── Design Phase
│   ├── Wireframes
│   ├── Visual design
│   └── Design review
└── Development Phase
    ├── Frontend development
    ├── Backend development
    └── Integration testing

Each phase is a layer, and tasks are assigned to the appropriate layer. This structure makes it easy to see what's happening in each phase and track overall project progress.

Layer Hierarchy: Parent and Child Layers

One of layer's most powerful features is the ability to create hierarchical relationships through parent and child layers. This nesting capability allows you to model complex project structures naturally.

How Hierarchy Works

• Root Layers: Top-level layers that have no parent (like "Discovery Phase" in the example above)
• Child Layers: Layers nested under a parent layer (like "Wireframes" under "Design Phase")
• Sub-layers: Another term for child layers, emphasizing the nested relationship

You can nest layers multiple levels deep, though we recommend keeping it to 2-3 levels maximum for clarity. The typical pattern is:

Level 1 (Root) → Level 2 (Child) → Level 3 (Grandchild)

Benefits of Hierarchical Organization

Better Organization: Complex projects naturally break down into smaller pieces. Hierarchy lets you model this structure directly in your taskboard.

Flexible Filtering: View all tasks in a parent layer along with its children, or filter to show just a specific child layer.

Progress Rollup: Progress from child layers can roll up to show overall parent layer completion (future feature).

Natural Workflow: Your team already thinks in hierarchies—features contain tasks, phases contain stages, epics contain sprints.

Example: Software Development

Product Launch (Root Layer - Epic)
├── Authentication Feature (Child Layer - Epic)
│   ├── Sprint 1: Oct 1-14 (Grandchild Layer - Sprint)
│   │   ├── Task: Design login UI
│   │   ├── Task: Implement OAuth
│   │   └── Task: Write auth tests
│   └── Sprint 2: Oct 15-28 (Grandchild Layer - Sprint)
│       ├── Task: Password reset flow
│       └── Task: Two-factor authentication
└── Dashboard Feature (Child Layer - Epic)
    └── Sprint 3: Oct 29-Nov 11 (Grandchild Layer - Sprint)

This three-level hierarchy lets you organize by theme (Product Launch), feature area (Authentication, Dashboard), and time period (Sprints).

Layer Types: Epic, Sprint, Stage, Milestone, Custom

Waymaker provides five predefined layer types, each designed for specific organizational purposes. Understanding these types helps you structure your taskboard to match your project methodology.

Epic

Purpose: Large features, initiatives, or bodies of work that span multiple iterations

Best For: Agile/Scrum projects, feature planning, strategic initiatives

Typical Duration: Weeks to months

Example: "User Authentication System", "Payment Processing", "Mobile App Launch"

Epics represent significant chunks of functionality that are too large to complete in a single sprint or iteration. They typically break down into smaller user stories or tasks across multiple sprints.

Sprint

Purpose: Time-boxed iterations of work, typically 1-4 weeks

Best For: Agile/Scrum teams, iterative development, regular delivery cycles

Typical Duration: 1-4 weeks (most commonly 2 weeks)

Example: "Sprint 12: Oct 1-14", "Q4 Sprint 3", "MVP Sprint 5"

Sprints are the heartbeat of agile development. Each sprint has defined start and end dates, a goal, and a set of tasks the team commits to completing.

Stage

Purpose: Sequential phases of work in a linear project plan

Best For: Waterfall projects, traditional project management, process workflows

Typical Duration: Varies widely based on project

Example: "Requirements Gathering", "Design & Planning", "Implementation", "Testing & QA"

Stages represent distinct phases that typically complete before the next phase begins. They're ideal for projects with clear sequential dependencies.

Milestone

Purpose: Significant checkpoints, deliverables, or decision points

Best For: Project gates, key deliverables, stakeholder reviews, go/no-go decisions

Typical Duration: Point in time (not a duration)

Example: "Design Approval", "MVP Launch", "Requirements Sign-off", "Beta Release"

Milestones mark important moments in your project timeline. They often represent deliverables, approvals, or transitions between project phases.

Custom

Purpose: Flexible layer type for unique organizational needs

Best For: Projects that don't fit standard methodologies, specialized workflows, creative use cases

Typical Duration: Whatever fits your needs

Example: "Q4 Initiatives", "Client A Work", "Backend Team Tasks", "Bug Fixes"

Custom layers give you complete flexibility to organize work in ways that make sense for your specific context. Use them when the predefined types don't quite fit your needs.

Layer Type and Color Coding

Each layer type can be assigned a color to provide visual distinction in your taskboard. This color coding helps you quickly identify different types of work at a glance.

Color Best Practices:

• Use consistent colors across your organization (e.g., all sprints in blue, all milestones in gold)
• Match colors to your layer types for quick recognition
• Avoid using too many different colors—stick to 4-6 maximum
• Consider using your brand colors for client-specific layers
• Use color intensity to indicate priority or status

The layer color appears in the layer dropdown when creating/editing tasks, in the layer manager sidebar, and can be used to visually group tasks in your Kanban view.

Layers vs Sections: Understanding the Difference

A common question when starting with taskboards is: "What's the difference between layers and sections?" Both organize tasks, but in fundamentally different ways.

Sections: Horizontal Organization (Workflow Status)

Sections are the columns in your Kanban board that represent workflow states:

• Backlog
• To Do
• In Progress
• Review
• Done

Purpose: Sections show where a task is in your workflow—its current status or stage of completion.

Movement: Tasks move horizontally across sections as work progresses (To Do → In Progress → Done).

Always Present: Every task is always in exactly one section.

Visual Representation: Vertical columns in Kanban view.

Layers: Vertical Organization (Logical Grouping)

Layers are organizational containers that group related tasks:

• Features
• Phases
• Time periods
• Themes
• Teams

Purpose: Layers show what a task belongs to—its context within the larger project.

Movement: Tasks typically stay in the same layer unless project scope changes.

Optional: Tasks can exist without being assigned to any layer.

Visual Representation: Rows in Kanban view (optional), filters in list view, hierarchical tree in layer manager.

Sections + Layers = Two-Dimensional Organization

The real power comes from using both sections and layers together:

                To Do  |  In Progress  |  Review  |  Done
                -------+---------------+---------+-------
Epic: Auth     Task A  |    Task B     |         | Task C
Epic: Dashboard Task D  |               | Task E  |
Sprint 1       Task F  |    Task G     |         |
Sprint 2               |    Task H     | Task I  |

This two-dimensional view lets you see:

• Horizontal: What stage each task is in (workflow status)
• Vertical: What each task belongs to (organizational context)

When to Use Each

Use Sections for:

• Workflow states (To Do, In Progress, Done)
• Status tracking (Not Started, Active, Blocked, Complete)
• Process steps that every task goes through
• Kanban workflow management

Use Layers for:

• Grouping tasks by feature, phase, or theme
• Organizing work by time period (sprints, quarters)
• Breaking down complex projects into manageable pieces
• Filtering large task lists to focus on specific work
• Tracking progress at different project levels

Use Both Together:

• Complex projects with multiple features or phases
• Agile projects with epics and sprints
• Projects where you need to track both status AND context
• Team environments where people work on different areas

When to Use Layers

Layers add organizational power, but they also add complexity. Here's how to decide when layers make sense for your taskboard.

Use Layers When:

Your project is complex and multi-faceted

• More than 30-40 tasks that fall into natural groupings
• Multiple features, phases, or workstreams
• Work that spans multiple time periods

You need to track progress at multiple levels

• Overall project progress plus feature-level progress
• Phase completion alongside overall project completion
• Sprint velocity and epic burn-down

Your team works in iterations or phases

• Agile sprints or iterations
• Waterfall phases or stages
• Regular release cycles

You need to filter and focus

• Different team members work on different features
• You want to view "just this sprint" or "just this phase"
• Large backlogs that need to be manageable

You're following a specific methodology

• Scrum (epics and sprints)
• Waterfall (phases and stages)
• Kanban with swim lanes
• SAFe or other scaled agile frameworks

Skip Layers When:

Your project is simple and straightforward

• Fewer than 20-30 tasks
• All tasks are roughly equal in scope
• No natural groupings emerge

You're managing a single workflow

• Support tickets or bug tracking
• Daily operational tasks
• Simple to-do lists

The team is very small

• Solo work or pairs
• Everyone works on everything
• No need to divide and focus

Status is all you need to track

• Workflow state (To Do → Done) is sufficient
• No need for additional context or grouping

The Decision Framework

Ask yourself these questions:

1. Complexity: Does my project have natural groupings (features, phases, themes)?

   • Yes → Layers likely helpful
   • No → Skip layers, use sections only

2. Scale: Do I have more than 30 tasks on this board?

   • Yes → Layers help manage the volume
   • No → Probably don't need layers yet

3. Methodology: Am I following agile, waterfall, or another structured approach?

   • Yes → Layers essential for methodology
   • No → Evaluate based on other factors

4. Team: Do different people work on different parts of the project?

   • Yes → Layers help divide the work
   • No → Less critical, but still potentially useful

5. Duration: Will this project last more than a few weeks?

   • Yes → Layers help organize over time
   • No → Simple structure likely sufficient

Layers in Agile Methodology

Agile teams use layers to organize work hierarchically, typically with epics as parent layers and sprints as child layers.

Typical Agile Layer Structure

Product Backlog Board
├── Epic: User Management
│   ├── Sprint 10 (Oct 1-14)
│   │   ├── User Story: Login page
│   │   ├── User Story: Password reset
│   │   └── User Story: Social auth
│   ├── Sprint 11 (Oct 15-28)
│   │   ├── User Story: Profile editing
│   │   └── User Story: Avatar upload
│   └── Sprint 12 (Oct 29-Nov 11)
├── Epic: Reporting Dashboard
│   ├── Sprint 11 (Oct 15-28)
│   │   ├── User Story: Chart components
│   │   └── User Story: Data API
│   └── Sprint 12 (Oct 29-Nov 11)
└── Backlog (Custom Layer)
    └── Unscheduled user stories

How It Works

Epics represent large features or initiatives. They're the "what" you're building.

Sprints represent time-boxed iterations. They're the "when" you're building it.

User Stories (tasks) are the specific work items. They're the "how" you're building it.

The Agile Workflow

1. Plan Epics: Identify major features or bodies of work
2. Create Epic Layers: Set up an epic layer for each major feature
3. Create Sprint Layers: Under each epic, create sprints with start/end dates
4. Break Down Work: Add user stories to the appropriate epic
5. Sprint Planning: Move stories from the backlog into the current sprint layer
6. Track Progress: Watch as stories flow through your workflow sections (To Do → Done)
7. Sprint Review: Review completed work in the sprint layer
8. Start Next Sprint: Create the next sprint layer and plan new work

Benefits for Agile Teams

• Velocity Tracking: See how many story points complete per sprint
• Epic Progress: Track progress toward completing each major feature
• Backlog Management: Keep unscheduled work in a "Backlog" layer
• Sprint Focus: Filter to show only the current sprint
• Cross-Epic Sprints: A single sprint can include stories from multiple epics

Layers in Waterfall Methodology

Waterfall projects use layers to represent sequential phases and stages, with clear dependencies and milestones.

Typical Waterfall Layer Structure

Website Redesign Project
├── Phase 1: Discovery (Weeks 1-2)
│   ├── Stage: Stakeholder Interviews
│   │   ├── Task: Interview CEO
│   │   ├── Task: Interview dept heads
│   │   └── Task: Compile insights
│   ├── Stage: Competitive Analysis
│   │   ├── Task: Identify competitors
│   │   ├── Task: Analyze features
│   │   └── Task: Create comparison matrix
│   └── Milestone: Requirements Sign-off
├── Phase 2: Design (Weeks 3-6)
│   ├── Stage: Information Architecture
│   ├── Stage: Wireframes
│   ├── Stage: Visual Design
│   └── Milestone: Design Approval
├── Phase 3: Development (Weeks 7-14)
│   ├── Stage: Frontend Development
│   ├── Stage: Backend Development
│   └── Stage: Integration
├── Phase 4: Testing (Weeks 15-16)
│   ├── Stage: QA Testing
│   ├── Stage: User Acceptance Testing
│   └── Milestone: Go/No-Go Decision
└── Phase 5: Launch (Week 17)
    ├── Stage: Deployment
    ├── Stage: Training
    └── Milestone: Project Complete

How It Works

Phases represent major project stages. They typically complete sequentially (Phase 1, then Phase 2, then Phase 3).

Stages are sub-divisions within phases. They may run sequentially or in parallel.

Milestones mark key decision points, deliverables, or phase gates.

Tasks are the specific work items within each stage.

The Waterfall Workflow

1. Plan Phases: Break the project into major sequential phases
2. Create Phase Layers: Set up a root layer for each phase with date ranges
3. Define Stages: Under each phase, create stage sub-layers
4. Add Milestones: Create milestone layers at key transition points
5. Break Down Work: Add tasks to the appropriate stages
6. Sequential Execution: Complete Phase 1 before starting Phase 2
7. Gate Reviews: Use milestone tasks to track approvals and go/no-go decisions
8. Track Critical Path: Monitor dependencies between tasks and phases

Benefits for Waterfall Teams

• Phase Gates: Clear milestones between major phases
• Sequential Dependencies: Model that Design must finish before Development starts
• Timeline Visualization: Gantt view shows the entire project timeline
• Critical Path: Identify which tasks are blocking progress
• Change Control: Track scope changes at the phase/stage level
• Resource Planning: Allocate resources by phase

Methodology Mapping: Agile vs Waterfall

Understanding how to map layers to your methodology helps you set up your taskboard for success.

Agile Mapping

Layer Level	Layer Type	Represents	Duration	Example
Root	Epic or Theme	Major feature area	Months	"User Management"
Child	Sprint	Time-boxed iteration	1-4 weeks	"Sprint 10: Oct 1-14"
Tasks	User Story	Specific functionality	Days	"As a user, I can reset my password"

Key Characteristics:

• Iterative and incremental
• Sprints are time-boxed
• Epics span multiple sprints
• Flexible scope within iterations
• Velocity and burndown tracking

Waterfall Mapping

Layer Level	Layer Type	Represents	Duration	Example
Root	Phase	Major project phase	Weeks	"Design Phase"
Child	Stage	Sub-phase or activity	Days to weeks	"Wireframes"
Milestone	Milestone	Gate or deliverable	Point in time	"Design Approval"
Tasks	Task	Specific work item	Hours to days	"Create home page wireframe"

Key Characteristics:

• Sequential and linear
• Phases complete before next begins
• Clear milestones and gates
• Fixed scope per phase
• Gantt charts and critical path

Hybrid Approaches

Many teams use a hybrid approach combining elements of both:

Scrumban: Kanban flow + Sprint time-boxing

Sprint 10 (Layer - Sprint)
├── Tasks flow through Kanban columns
└── Sprint has time-box but continuous flow

Wagile (Water-Scrum-Fall): Waterfall planning + Agile execution

Phase: Discovery (Waterfall)
Phase: Development (Agile with Sprints)
Phase: Launch (Waterfall)

SAFe (Scaled Agile Framework): Multiple layer levels

Program Increment (Root - Custom)
├── Epic (Child - Epic)
│   └── Sprint (Grandchild - Sprint)
│       └── User Stories (Tasks)

The flexibility of layer types (Epic, Sprint, Stage, Milestone, Custom) means you can structure your taskboard to match your actual methodology, not force your methodology to fit a rigid tool.

Tips & Best Practices

• Start Simple: Begin with 2-3 root layers and add complexity only as needed
• Consistent Naming: Use clear, predictable names like "Sprint 10" not "Current Sprint"
• Meaningful Colors: Assign colors that help distinguish layer types or priority
• Limit Depth: Keep layer hierarchy to 2-3 levels maximum for clarity
• Date Ranges: Always set start and end dates for sprints and phases
• Review Regularly: Archive completed layers to keep your active board clean
• Team Alignment: Ensure everyone understands the layer structure and naming conventions
• Template Reuse: Once you find a structure that works, use it as a template for new boards

Common Mistakes to Avoid

• Over-nesting: Creating too many layer levels (4+) makes navigation confusing. Stick to 2-3 levels.
• Inconsistent Types: Mixing layer types inconsistently (e.g., using "Epic" for phases). Choose types that match your methodology.
• No Dates on Sprints: Sprints should always have start and end dates. This enables timeline views and velocity tracking.
• Too Many Layers: Creating a layer for every small grouping. Aim for 5-15 active layers, not 50+.
• Forgetting Backlog: Not creating a "Backlog" or "Unscheduled" layer for tasks that aren't yet assigned to a sprint or phase.
• Ignoring Colors: Not using layer colors, making it hard to visually distinguish different types of work.
• Layer Paralysis: Spending too much time perfecting layer structure instead of getting work done. Good enough is often perfect.

Related Articles

• Creating and Managing Layers - Step-by-step guide to creating layers
• Layer Types Explained - Deep dive into each layer type
• Using Layers for Agile Projects - Complete agile workflow with layers
• Using Layers for Waterfall Projects - Waterfall project setup
• Layer Progress Tracking - Monitoring layer completion
• Layer Best Practices - Advanced organization strategies

Need More Help?

If you have questions about layers or need assistance setting up your taskboard structure, please contact support or visit our community forums. Our team is here to help you design the perfect organizational structure for your projects.