Estimation And Planning

Why this matters

Backend engineers are asked: How long will this take? When can we ship? Good estimation and planning help you set realistic timelines, align dependencies (DB, DevOps, frontend), and reduce surprises. This is collaboration-heavy work: you communicate scope, risks, and trade-offs so the team can make decisions.

• Real tasks: sizing new endpoints and migrations, planning incident fixes, sequencing integrations, forecasting a sprint or release.
• Outputs you produce: task breakdowns, ranges (best/likely/worst), risk notes, definition of done, and a simple timeline.

Concept explained simply

Estimation is a reasoned guess of effort or duration. Planning turns that guess into an ordered list of tasks with owners, dependencies, and a clear definition of done.

Mental model

• Break it: split work until each piece is small and knowable.
• Bound it: give a range (optimistic–likely–pessimistic) and state your confidence.
• Buffer it: protect against risks with explicit contingency.
• Bridge it: communicate assumptions and dependencies so others can help.

Estimation tools you will use

1) Three-point estimates (PERT-style)

Estimate Optimistic (O), Most Likely (M), and Pessimistic (P). Expected effort E ≈ (O + 4M + P) / 6. Use the range (O–P) to communicate uncertainty.

Tip: when to widen ranges

Widen when there are unknowns (new tech, external APIs), high coupling, or first-time tasks. Narrow as you learn.

2) T-shirt sizes and story points

• T-shirt sizes (XS–XL) for early, fuzzy ideas.
• Story points reflect relative complexity and uncertainty; later you map to time using team throughput.

3) Confidence and buffers

• Say the confidence: e.g., "4–6 hours at ~70% confidence."
• Add explicit contingency for identified risks (e.g., +20% only for integration risks you listed).

4) Dependencies and critical path

• Dependency: work that must be done before another starts.
• Critical path: the longest chain of dependent tasks; any delay here moves the delivery date.

Planning basics for backend work

Worked examples

Example 1 — New REST endpoint: GET /v1/reports/{id}

• Scope: auth check, fetch from DB, serialize, 404/403, rate limiting, logs.
• Breakdown & three-point estimates:
  • Contract & handler: O=1h M=2h P=4h
  • Repo query + indexes: O=1h M=3h P=6h
  • Auth & rate limit wiring: O=0.5h M=1h P=2h
  • Tests (unit + integration): O=1h M=2h P=4h
  • Observability (log/metrics): O=0.5h M=1h P=2h
• Expected effort (sum of E): ≈ (2.0 + 3.0 + 1.0 + 2.0 + 1.0) = 9 hours (~1–1.5 days). Range: ~4–18 hours. Risk: slow query if missing index.
• Plan: do repo query first; measure latency; add index if needed; then handler, tests, and logs.

Example 2 — Database migration with zero downtime

• Scope: add column, backfill, dual-write, switch reads, remove legacy field.
• Dependencies: feature flag service, migration window, DBA approval.
• Breakdown & estimates (selected):
  • Migration script (safe): O=1h M=2h P=3h
  • Backfill job: O=2h M=4h P=8h
  • Dual-write changes: O=2h M=4h P=8h
  • Switch reads + monitor: O=1h M=2h P=4h
  • Cleanup: O=1h M=2h P=3h
• Critical path: backfill → switch reads. Risk: backfill time varies with data size. Buffer: +25% for backfill only.
• Plan: run backfill in small batches, pause-on-error; add dashboards; set rollback plan.

Example 3 — Payment provider integration

• Scope: create charge, webhooks, idempotency, retries, error mapping, receipts.
• Unknowns: provider webhook reliability; rate limits.
• Spike (timeboxed 1 day): validate SDK, sandbox events, idempotency keys. Outcome drives final estimate.
• Post-spike estimate: 4–7 days at ~70% confidence; buffer 1 day for webhook flakiness.
• Plan: build idempotent handlers first; set replayable queues; add observability for webhook failures.

Mini hands-on: do one quick estimate now

Prompt

Task: add a new field to user profile ("timezone") surfaced in two endpoints and persisted in DB with validation. Do a quick three-point estimate and a 5-step plan.

Example approach

• Breakdown: schema/migration, repo update, validation, update endpoint, read endpoint, tests, logs.
• Three-point per item; call out dependency on frontend for value format.
• Plan: schema first; validation; update endpoints; tests; deploy behind a flag.

Exercises

Complete these and compare with the provided solutions. You can take the Quick Test anytime; saving progress is available to logged-in users only.

1. Exercise 1: Estimate a CRUD endpoint for creating a project with validation and audit logging. Provide a breakdown, three-point estimates, risks, and a brief plan. (See solution below.)
2. Exercise 2: Plan a read-heavy DB migration moving a column into a new table. Identify the critical path, dependencies, buffers, and rollback steps. (See solution below.)

Exercise 1 — Show solution

Suggested breakdown: request model + validation, handler + repo insert, audit log emit, tests, metrics. Three-point each (e.g., handler O=1h M=2h P=4h...). Risks: duplicate names, audit sink throughput. Plan: contract first, write path, audit, tests, load test insert.

Exercise 2 — Show solution

Critical path: create new table → dual-write → backfill → switch reads → cleanup. Dependencies: DBA approval, feature flag. Buffers: +20% on backfill only. Rollback: revert reads, stop dual-write, restore from snapshot if necessary.

Exercise checklist

• Did you state assumptions and define "done"?
• Did you break work into 1–8 hour pieces?
• Did you provide ranges, not single numbers?
• Did you identify dependencies and the critical path?
• Did you add explicit buffers only where risks exist?

Common mistakes and self-check

• Single-number estimates. Fix: give a range with confidence.
• No dependency mapping. Fix: draw arrows; find the critical path.
• Hidden buffer. Fix: state buffer and what it covers.
• Skipping non-functional needs. Fix: include performance, security, observability in DoD.
• Not updating estimates after learning. Fix: re-estimate after spikes or discoveries and communicate changes.

Practical projects

• Take a small service you own and create an estimation playbook page: breakdown template, three-point sheet, risk checklist.
• Run a 2-hour spike on a new library; capture what changed your estimate and update the plan.
• Simulate a release plan: pick 5 tasks, map dependencies, highlight the critical path, and assign buffers.

Who this is for

• Backend engineers who need to forecast work and communicate delivery timelines.
• Leads who coordinate backend, frontend, and infra dependencies.

Prerequisites

• Basic backend development experience (APIs, DB, testing).
• Comfort splitting work into small tasks.

Learning path

• Before this: requirements clarification, API design basics.
• This subskill: estimation methods, dependency mapping, planning communication.
• After this: release planning, risk management, incident response planning.

Next steps

• Apply three-point estimates on your next ticket and share the range and confidence.
• Introduce a visible risk buffer and track how much you consume.
• Calibrate using your team’s historical throughput for similar tasks.

Mini challenge

You have 2 weeks to ship a feature with an external API dependency that has a 3–5 day approval time. Draft a plan that meets the date by parallelizing work. Identify what goes on the critical path and where you place buffers. Keep the write-up under 150 words.

Quick Test (take it below)

The quick test is available to everyone. Only logged-in users will have their progress saved.