Mission-Centered Design · Part 6 of 9

Production

Keeping scope tight during sprints, slicing work, triaging bugs and tracking real progress.

The Designer in Production

The goal of production is to deliver tasks as quickly and efficiently as possible, and to prioritize them across sprints so each sprint is well spent. The designer’s role shifts to:

  • Making task-level design decisions, many of them driven by technical limits, and recording them in acceptance criteria during refinement and planning
  • Knowing when to escalate a decision for discussion and when to just make the call
  • Backbriefing stakeholders on those decisions during sprint reviews
  • Watching the horizon. In pre-production your head is above the water; once you’re delivering tasks, it’s under. Someone who isn’t heads-down in code has to keep asking “are we on track?”

The Team Is a Factory

Think of the team as a production line. Only the work leaving the right edge of the board matters, so optimizing one station is useless: the fastest salt-pourer on a butter line doesn’t produce more butter if the churn is slow. Help wherever the bottleneck is, for example by filing a bug report yourself instead of waiting for QA to write it. (For more, read The Goal and The Phoenix Project.)

Run stand-ups the same way. They are about handoffs and blockers (who will review or test this today, and what will unblock that), not status reports on what each person did yesterday.

Keep Task Scope Tight

Poorly defined tasks lead to waste and chaos. Beyond writing good tasks, use definitions of ready and done, timebox hard-to-bound work, abort tasks that get out of control, and hold quick daily reviews of work in progress.

Swarm

When one person’s task stalls, it is usually better for the team to help move it to done than to start something new. Form a small sub-team, name a coordinator, and let them self-organize.

Slice the Work

Plan delivery in increments: a minimum viable product (MVP), then improved versions. Slice horizontally (one layer of the system across many features) or vertically (one feature through every layer) depending on what gets useful software in front of users soonest.

“Hacky” isn’t a dirty word. Judge code by how many things depend on it and how often it is touched. Foundational code must be clean. A self-contained one-off that will never change can be quick and dirty, with a comment explaining why. And refactoring always sounds quick; it rarely is.

Triage Bugs

  1. Input: make it cheap for anyone to report a bug, even in rough form.
  2. Filter: someone removes duplicates and mis-reports.
  3. Triage: a small group, for example designer, QA and product owner, sets priority and next steps.
  4. Report: QA turns bugs into detailed reports in the backlog.
  5. Prioritize: the product owner and team weigh bugs against the rest of the backlog.

Track Real Progress

If you can’t answer “when will it be done?”, you aren’t managing the project. “Time spent divided by the original estimate” is not percent complete. Instead, use several measures and look for agreement between them:

  • Current (not original) estimate versus time spent
  • Requirements passing validation versus total
  • Features complete versus total
  • Use cases passing their quality target versus total
  • Open bugs at each priority versus the quality target

Use relative sizes, then forecast with historical velocity. For example, four requirements done in the last two months is a velocity of two a month. And remember: releasing always takes longer than it looks once development seems complete.

The 25% Rule

If you are about a quarter of the way through a project and can’t show a single completed requirement, feature or use case, it will very likely be late and over budget. “We can’t finish any requirements because we’re still building the big back-end piece” is how teams fool themselves. Discover trouble late and all that’s left is damage control. Discover it early and you can still cut scope you never promised.

Run Regular Project Reviews

The goal of a project review is to judge the project’s health and decide what it needs. At a minimum, cover:

  • Requirements and budget burn: requirements done, past pre-production and total; budget days spent and remaining; the current trend line against the ideal.
  • Artifact status: in pre-production, requirements analysis, use cases, UX designs, technical architecture, interface designs, QA plan and licensing. Toward release, test cases, automated tests, validation results, documentation, a UX review, known issues, release notes and marketing materials.
  • External coordination: release planning, work shared with other teams, and handover or closeout.
  • Milestones: progress toward the next one, and whether future dates and scope need to change.

Key Techniques

Backlog refinement, playtesting, bug triage, project progress tracking and team standard operating procedures. See the technique library.

Let’s Talk

I am open to senior product roles in defense tech. I also enjoy hearing from fellow Operation Flashpoint and VBS veterans, and from anyone writing or podcasting about simulation or war in games.

info [at] andrewbarron.net