Core Definitions

Before we start rearranging sticky notes like it’s modern art, let’s define a few recurring terms:

• Backlog: An ordered list of work items, ideally by value, not whim.
• Sprint: A fixed timebox (1–4 weeks) in which Scrum teams deliver a slice of value.
• WIP (Work in Progress): The number of items being worked at the same time. Too much WIP = stalled flow.
• Lead time: Time from request to delivery. Customer’s stopwatch.
• Cycle time: Time from “started” to “done.” Team’s stopwatch.
• Throughput: Number of items completed per time period.
• Flow efficiency: Active time / total time. The “how much waiting is ruining our vibe” metric.

Scrum Roles & Artifacts

Roles:

• Product Owner: Orders the backlog to maximize value.
• Scrum Master: Coaches the team, improves flow, removes impediments.
• Developers: Everyone building the Increment (coders, testers, ops, designers).

Artifacts:

• Product Backlog: Ordered list of work.
• Sprint Backlog: Selected work + plan for achieving the Sprint Goal.
• Increment: The result of the sprint, meeting the team’s Definition of Done.

Tip: Make Definition of Done explicit (tests, security checks, docs, deployment). Shipability is a feature.

Scrum Events That Matter

• Sprint Planning: What can we deliver and how?
• Daily Scrum: 15 minutes to inspect and adapt the plan. Not a status theater.
• Sprint Review: Show real working software to stakeholders. Feedback > applause.
• Sprint Retrospective: Improve the system, not just the people. Change one thing next sprint.

Cadence builds habit. Habit builds velocity (the sustainable kind).

Kanban: Policies & WIP

Set the rules of the road:

• WIP limits: “Only 2 items in Code Review,” not “as many as fit on my second monitor.”
• Pull policies: Upstream pulls from downstream. Avoid pushing half-baked work.
• Classes of service: Expedite, Fixed date, Standard, Intangible (tech debt).

When blocked, swarm to unblock before starting new work. Starting is fun; finishing pays.

Lean At A Glance

What it is: A mindset and practices to maximize value and minimize waste across the whole system.

Core principles:

• Define value from the customer’s perspective
• Map the value stream
• Create flow
• Establish pull
• Pursue perfection through continuous improvement

Lean isn’t a board. It’s how you decide what to build and how to build it with less nonsense.

Choosing The Fit

Use Scrum when:

• Work benefits from timeboxed goals and demos
• Stakeholders want regular, predictable checkpoints
• Team is cross-functional and product-focused

Use Kanban when:

• Work is variable, interrupt-driven, or queue-based (incidents, infra)
• You need continuous flow, not timeboxes
• You want to start improving tomorrow with what you have

Use Lean always:

• It guides how to remove waste and improve the system regardless of method

Example: Feature Delivery

Scenario: Product team delivering a new onboarding flow.

• Scrum fit: Plan a 2-week sprint with a clear Sprint Goal (reduce time-to-first-value). Demo working slices each sprint.
• Kanban assist: Add WIP limit of 1–2 in Code Review and Testing. Track cycle time to see where work stalls.
• Lean lens: Remove rework by automating acceptance tests and feature flags to reduce waiting and defects.

Result: Steady cadence, visible flow, fewer surprises.

Example: Incidents & Ops

Scenario: SRE team handling alerts, maintenance, and small improvements.

• Kanban fit: Visualize Expedite lane for incidents, strict WIP limits, pull policies.
• Metrics: Watch work item age and lead time for expedited work. Keep a small Standard WIP for improvements.
• Lean lens: Reduce waiting by automating runbooks; cut motion by centralizing dashboards.

Result: Faster recovery, fewer half-started tasks, space for proactive work.

Example: Platform/Infra

Scenario: Platform team providing CI/CD, environments, and shared services.

• Blend: Monthly Scrum planning/review/retro for roadmap; Kanban for daily flow.
• Policies: Classes of service to balance fixed-date migrations vs standard requests.
• Lean lens: Value Stream Map the deployment path; remove overprocessing (duplicate approvals) and transport (handoffs).

Result: Predictable outcomes with flexible intake.

Scaling Without Drama

Multiple teams? Keep it simple:

• Align on Definition of Done and work item sizing heuristics
• Use a rolling wave roadmap; avoid massive batch planning
• Sync on dependencies via a weekly cross-team flow review (not status—focus on risks, blockers, and options)
• Limit WIP at both team and program levels

Scaling is adding constraint elegance, not meetings.

Anti-Patterns To Avoid

• Zombie Scrum: All ceremonies, no working increments
• Kanban Wallpaper: Pretty board, unlimited WIP
• Cargo Cult Metrics: Measuring what’s easy, ignoring flow
• Hero Culture: Fixing symptoms instead of systems
• Batch-and-Queue: Giant PRs, giant projects, giant regrets
• Backlog Hoarding: Thousands of tickets you’ll never do—archive or say no

If everything is priority, nothing flows.

Quick-Start Cheat Sheets

Scrum (start tomorrow):

• Choose 2-week sprints
• Define a crisp Sprint Goal
• Pull only what fits; leave slack for unplanned work
• Ship a real Increment
• Do a 30-minute retro: pick one improvement

Kanban (start this afternoon):

• Draw your workflow, set small WIP limits
• Establish explicit pull policies
• Visualize blockers and swarm them
• Track cycle time and throughput weekly
• Reduce WIP before adding people

Lean (start now):

• Map your value stream
• Identify top 1–2 wastes
• Run a small experiment to remove them
• Measure effect on lead time
• Repeat

Recap: The Playbook

• Scrum gives you cadence and feedback via sprints and reviews.
• Kanban gives you flow via WIP limits, pull, and metrics.
• Lean gives you systemic improvement by removing waste across the value stream.

Pick the starting point that fits your work. Blend deliberately. Measure flow, not feelings. And remember: starting is optional, finishing is mandatory.