The pie chart that lied politely
An engineering director prepares a quarterly business review. Leadership wants to know how engineering capacity is split across new features, reliability, and maintenance. The director exports tickets from the project tracker, maps each to a category, and produces a pie chart: 62% new capability, 18% reliability, 12% maintenance, 8% support.
The chart looks authoritative. But a staff engineer on the team points out three problems. First, a large infrastructure migration ticket was tagged "new capability" because it enabled a future feature, even though the work was entirely operational. Second, about 15% of the team's time went to code reviews, incident response, and ad-hoc investigations that never appeared in any ticket. Third, a single pull request that fixed a production bug also included a small feature tweak and a dependency upgrade -- it served three purposes at once.
The pie chart did not lie on purpose. It lied because the classification method forced single-purpose labels onto mixed-purpose work, ignored work that never became a ticket, and gave the impression of financial-grade precision where none existed. This guide helps you build an allocation picture that is useful for decisions precisely because it admits what it does not know.
Quick-start path
- Define four investment categories plus one explicit "unknown/unclassified" bucket. (10 minutes)
- Copy the worksheet below and fill in one recent iteration or sprint as a trial. (30 minutes)
- Have two engineers independently classify 10 work items each; compare disagreements. (20 minutes)
- Add a mixed-purpose split rule for items that span categories. (10 minutes)
- Present the allocation with the unknown bucket visible; use it to start a tradeoff conversation, not to report a financial number.
This path gets you a first draft in under two hours. Refinement happens through the ongoing review routine described later.
Define investment categories around the decisions they serve
Why categories exist
Investment categories are not accounting ledgers. They exist to help an engineering leader answer questions like: "Are we spending enough on reliability to meet our SLO targets?" or "Has maintenance crowded out new capability work this quarter?" If your categories do not map to decisions someone actually makes, they will rot.
Four categories plus unknown
| Category | Definition | Decision it informs |
|---|---|---|
| New capability | Work that delivers functionality a user could not access before, or meaningfully extends existing functionality. | Are we investing enough in product growth relative to our roadmap commitments? |
| Reliability | Work that improves uptime, performance, observability, or incident response -- without changing user-facing behavior. | Are we investing enough to meet our SLO targets and reduce on-call burden? |
| Maintenance | Dependency upgrades, refactors, test improvements, toolchain updates, and tech-debt reduction that preserve current functionality. | Is deferred maintenance accumulating risk we need to address? |
| Support | Customer escalations, internal tooling requests, sales engineering, and ad-hoc investigations that serve another team's immediate need. | Is support load displacing planned work, and should we invest in self-service instead? |
| Unknown/Unclassified | Work that cannot be confidently placed in any category, or work that was never tracked. | How much of our allocation picture is guesswork? Should we improve tracking before trusting the numbers? |
Why "unknown" is the most important category
Most allocation frameworks quietly distribute ambiguous work into the other buckets or simply ignore it. This makes the chart look cleaner and the numbers less trustworthy. An explicit unknown category does two things: it tells leadership how much of the picture is uncertain, and it creates pressure to improve classification over time without pretending the problem is already solved.
A team with 5% unknown has a credible allocation. A team with 30% unknown has a research project, not a report. Both are honest. Only the team that hides the 30% is dangerous.
When is the unknown bucket too large to trust the rest?
The 30% figure above is not arbitrary. Consider what happens to the other categories when the unknown bucket is large. If unknown is 10%, then even in the worst case -- every unknown person-day actually belongs to one category -- no single category's true value can differ from its reported value by more than 10 percentage points. If unknown is 30%, any category could be off by up to 30 points. A reported 40% new-capability figure might really be anywhere from 28% to 58% once unknowns are resolved. At that range, the allocation cannot distinguish between "we are heavily investing in features" and "we are splitting evenly across everything."
The practical heuristic: if unknown exceeds the size of your second-largest known category, the allocation is too uncertain for directional claims about any category except the largest. Present it as a data-quality baseline, not an investment picture, and focus your next sprint on reducing the unknown bucket before drawing conclusions.
When a platform team's work spans multiple product teams
The four-category framework assumes a team owns its own allocation. This breaks down when a platform or shared-services team builds infrastructure consumed by several product teams. A platform team's "new capability" is often another team's "reliability" or "maintenance." If you classify at the platform team level, the allocation reflects what the platform team intended. If you classify at the consuming team level, the allocation reflects where the value landed. Neither is wrong, but mixing the two in a single rollup creates double-counting or gaps.
Handle this with an explicit attribution rule in your worksheet: decide once whether shared work is classified by the producing team or the consuming team, document the choice, and apply it consistently. A practical default is to classify at the producing team and annotate which consuming teams benefit. When leadership asks "how much reliability investment did Product Team A receive?", you can answer from the annotations without re-classifying the platform team's records. If you roll up across multiple teams, include a "cross-team attribution" row that shows how much of the total comes from shared services, so readers know the single-team percentages do not capture the full picture.
Allocation worksheet (copyable)
Copy this worksheet into your team's wiki or shared document. Fill it in once per iteration (sprint, week, or month -- whatever your planning cadence is). Instructions follow the template.
ENGINEERING INVESTMENT ALLOCATION WORKSHEET
============================================
Team: [e.g., Payments Backend]
Period: [e.g., Sprint 24, 2025-06-02 to 2025-06-13]
Prepared by: [Name]
Classification reviewed by: [Second name -- required for validation]
CATEGORY SUMMARY
-----------------
| Category | Effort (person-days) | % of Total | Confidence | Notes |
|------------------|----------------------|------------|------------|--------------------------------|
| New capability | 18 | 40% | High | Mostly ticket-backed |
| Reliability | 9 | 20% | Medium | Includes SLO alerting work |
| Maintenance | 5 | 11% | High | Dependency upgrades |
| Support | 4 | 9% | Medium | 3 customer escalations |
| Unknown | 9 | 20% | -- | Reviews, meetings, unticketed |
| TOTAL | 45 | 100% | | |
MIXED-PURPOSE ITEMS (list items that span categories)
------------------------------------------------------
| Item ID / Description | Primary Category | Secondary Category | Split Estimate | Rationale |
|------------------------------|------------------|--------------------|----------------|----------------------------------|
| PAY-412: Retry + monitoring | Reliability | New capability | 70/30 | Retry is reliability; new retry |
| | | | | config UI is new capability |
| PAY-419: Customer debug | Support | Maintenance | 60/40 | Started as escalation, turned |
| | | | | into log format cleanup |
NON-CODE WORK INCLUDED IN UNKNOWN
-----------------------------------
| Activity | Estimated person-days | Could it be classified? |
|---------------------------|-----------------------|------------------------------------------------------------|
| Code review | 3 | Partially -- reviews serve the category of the PR reviewed |
| Incident response (no ticket) | 2 | Yes, if incidents are logged retroactively |
| Sprint planning, retro | 2 | No -- overhead, leave in unknown |
| Ad-hoc Slack investigations | 2 | Rarely -- too fragmented |
CROSS-TEAM ATTRIBUTION (if applicable)
----------------------------------------
| Consuming Team | Category credited | Effort (person-days) | Notes |
|----------------------|-------------------|----------------------|--------------------------------------|
| Checkout Frontend | Reliability | 3 | Shared retry library work benefits |
| | | | their payment flow |
| N/A this sprint | | | |
SAMPLED VALIDATION
-------------------
Items sampled: [e.g., 5 of 22 tickets]
Disagreements: [e.g., 1 of 5 -- PAY-415 classified as maintenance by preparer, reliability by reviewer]
Resolution: [e.g., Reclassified as reliability -- the refactor was triggered by a latency SLO breach]
Confidence note: [e.g., 80% agreement before discussion; 100% after. Sample is small.]
TRADEOFF OBSERVATIONS
----------------------
[Use this section to note what the allocation suggests about upcoming decisions.]
- New capability is at 40%, which aligns with our target of 40-50%.
- Unknown at 20% is higher than last sprint (12%). Incident response was elevated.
- Reliability investment dropped from 25% to 20%. Check whether SLO performance degraded.
How to use this worksheet
Effort units. Use person-days, not story points, commit counts, or lines of code. Person-days are imprecise but directionally comparable across sprints. Story points are team-relative and cannot be aggregated. Commit counts reward small commits and penalize large ones. Lines of code reward verbosity.
Confidence column. Mark each category High, Medium, or Low. High means most items are ticket-backed with clear descriptions. Medium means some items required judgment calls. Low means you are guessing. This column is what separates an honest allocation from a fictional one.
Mixed-purpose splits. When a work item spans categories, estimate a rough percentage split. Do not agonize over precision. A 70/30 split that is actually 60/40 is close enough. A 100/0 split that is actually 50/50 is not. If you cannot decide, put the item in unknown and note why.
Non-code work. Explicitly list activities that consumed time but do not appear in your ticketing system. This is where most hidden capacity goes. Even a rough estimate is better than omission, because omission makes the coded categories look larger than they are.
Cross-team attribution. If your team builds shared infrastructure, note which other teams benefit and in what category. This prevents the common failure where platform teams report 80% "new capability" while product teams feel they received no platform support.
Sampled validation. Have a second person independently classify a random sample of 5-10 items. Compare. Disagreements reveal ambiguous definitions, not mistakes. Resolve them and tighten your category definitions for next time.
Worked hypothetical scenario: a backend team's quarterly allocation
Setup (hypothetical)
A hypothetical backend team of 8 engineers works in two-week sprints. Over a quarter (6 sprints), leadership asks: "Where did our capacity go?"
The engineering manager fills out the worksheet for each sprint and aggregates. In practice, total available person-days vary sprint to sprint because of PTO, holidays, onboarding, and sick days. The uniform totals below (45 person-days each sprint) are a simplification for illustration; a real worksheet would show different totals per sprint, and the percentage column is what makes sprints comparable despite varying capacity.
Raw aggregation
| Category | Sprint 1 | Sprint 2 | Sprint 3 | Sprint 4 | Sprint 5 | Sprint 6 | Quarter Total | % |
|---|---|---|---|---|---|---|---|---|
| New capability | 20 | 22 | 18 | 14 | 10 | 12 | 96 | 36% |
| Reliability | 8 | 6 | 10 | 12 | 16 | 14 | 66 | 25% |
| Maintenance | 4 | 4 | 6 | 4 | 4 | 6 | 28 | 10% |
| Support | 4 | 2 | 4 | 6 | 8 | 6 | 30 | 11% |
| Unknown | 9 | 11 | 7 | 9 | 7 | 7 | 50 | 18% |
| Total | 45 | 45 | 45 | 45 | 45 | 45 | 270 | 100% |
What the data shows
New capability dropped from 44% in Sprint 1 to 27% in Sprint 6. Reliability climbed from 18% to 31%. Support nearly doubled. The manager's first instinct is alarm: "We're losing feature velocity."
What the data actually means
Before reacting, the manager checks context. In Sprint 3, a production incident triggered an SLO breach. The team committed to remediation work, which explains the reliability climb in Sprints 4-6. Support increased because a large customer entered onboarding and generated escalations.
The unknown bucket held steady at 16-24% across sprints. The manager notes that roughly 3 person-days per sprint are code review and 2 are meetings -- both are relatively fixed overhead. The remaining unknown is ad-hoc work that varies.
Applying the heuristic from the previous section: the unknown bucket (18% for the quarter) is smaller than the second-largest known category (reliability at 25%), so the allocation is directionally trustworthy. If unknown had been 28%, it would have exceeded reliability and the manager should have flagged the allocation as provisional.
Re-classification risk: what happens when the narrative changes
Midway through the quarter, the team classified the SLO remediation work as "reliability." But at the end of the quarter, a product manager points out that the remediation included a new circuit-breaker configuration UI that customers can now access. Should 2 person-days per sprint of that work be reclassified as "new capability"?
This is a real tension. If you reclassify retroactively, your sprint-level records no longer match what the team believed at the time. If you do not reclassify, the quarterly rollup understates new capability. The practical rule: allow retroactive reclassification only during the quarterly review, apply it to the quarterly total (not individual sprints), and document the change with a reason. In this case, moving 6 person-days from reliability to new capability shifts the quarterly picture from 36%/25% to 38%/22% -- a modest change that does not alter the narrative. If a retroactive reclassification would shift any category by more than 5 percentage points, present both the original and revised allocation so leadership can see the sensitivity.
The tradeoff conversation
The manager presents the allocation to leadership with this framing: "New capability dropped this quarter because we responded to a reliability incident and a customer onboarding wave. Both were the right calls. If we want to return to 40%+ new capability next quarter, we need either (a) fewer unplanned support requests, which means investing in self-service tooling, or (b) accepting that reliability remediation is complete and re-allocating those person-days."
This framing is possible only because the allocation was tracked with honest categories. If the unknown bucket had been zero and reliability had been folded into maintenance, the conversation would have been about the wrong things.
What the manager does not claim
The manager does not say "we spent $X on reliability" -- person-days are not dollars. Salaries vary, not all days are equal, and the allocation does not capture the cost of context-switching or the value of what was delivered. The allocation informs a conversation. It does not replace financial accounting.
Comparing realistic options for classification method
| Method | How it works | Strengths | Weaknesses | Best fit |
|---|---|---|---|---|
| Ticket-tag at creation | Product or engineering tags each ticket with a category when it enters the backlog. | Low ongoing effort. Consistent if definitions are clear. | Ignores non-ticketed work. Mixed-purpose items get forced into one bucket. Tags go stale if scope changes. | Teams with strong ticket discipline and low unplanned work. |
| Retrospective classification | At the end of each sprint, the team classifies completed work. | Captures scope changes and mixed-purpose items. Can include non-ticketed work. | Relies on memory. Takes 15-30 minutes per sprint. May invite revisionism ("that was really new capability"). | Teams willing to spend time on sprint-end review. |
| Sampled classification | Classify a random sample of work items each sprint; extrapolate. | Low effort. Surfaces disagreements. Good enough for directional decisions. | Less precise for small teams. Extrapolation adds noise. | Large teams where classifying every item is impractical. |
| Automated proxy (e.g., repo or label mapping) | Map repositories or file paths to categories automatically. | No manual effort after setup. Scales. | Assumes repos map cleanly to categories (often false). Misses non-code work entirely. Creates false precision. | Teams with strict repo-per-concern architecture. |
Recommendation for most teams: Start with retrospective classification. It is the most honest method because it uses the team's judgment after the work is done, not before. Add sampled validation to catch drift. If your team examines delivery data using a tool like FeatureFactory, the signals it surfaces can inform classification -- but the judgment call about which category a work item belongs to remains human.
Adapting to team context
- Small team (3-5 engineers): Classify every item. The volume is manageable and sampling is unreliable at this scale.
- Medium team (6-15 engineers): Retrospective classification with sampled validation. Rotate the validator role.
- Multiple teams reporting to one leader: Standardize category definitions across teams. Accept that unknown percentages will vary -- that is information, not a problem. Use FeatureFactory's planning tools to organize signals across teams if you are already consolidating product work there.
- Teams with heavy unplanned work: Your unknown bucket will be large. That is correct. Do not shrink it by guessing. Instead, invest in retroactive ticketing for incidents and escalations so future sprints have better data.
- Platform/shared-services teams: Use the cross-team attribution row. Without it, your allocation will look like pure "new capability" while the teams you serve feel under-supported. The attribution row also helps leadership understand the true reliability or maintenance investment across the organization, not just within a single team's ledger.
Failure symptoms, corrective actions, and escalation points
| Symptom | Likely cause | Corrective action | Escalate when... |
|---|---|---|---|
| Unknown category is consistently above 30% | Non-ticketed work is not being captured; ad-hoc requests bypass the backlog. | Introduce a lightweight "interrupt ticket" that takes under 1 minute to create. Retroactively log incidents. | After two sprints of trying, the percentage does not drop. Escalate to discuss whether the planning process needs structural change. |
| Two classifiers disagree on more than 40% of sampled items | Category definitions are ambiguous or team members interpret them differently. | Run a 30-minute calibration session: present 5 ambiguous items, discuss, and update the definitions document. | Disagreement persists after two calibration sessions. Definitions may need to be restructured around different decision boundaries. |
| Leadership treats the allocation as a financial report | The worksheet was presented without the confidence column or unknown bucket, or someone converted person-days to dollars. | Re-present with confidence notes. Explicitly state that person-days are not interchangeable with cost. Add a disclaimer to every allocation slide. | Leadership makes budget decisions based on the allocation without consulting finance. Escalate to CFO or finance partner. |
| One category absorbs everything ("90% new capability") | Classification is too generous to the dominant category, or mixed-purpose items are not being split. | Audit the top 10 items in the dominant category. Check whether any include reliability, maintenance, or support work. Apply splits. | After audit, the category is still above 80%. This may be accurate -- but verify by checking whether reliability and maintenance needs are actually being met. |
| Allocation stays identical across sprints | Classification is being copied, not re-done; or the team's work mix genuinely does not change. | Check whether the same items are being re-classified or whether new items are getting the same default tag. | If the allocation is truly static for 4+ sprints, the exercise is either not being done honestly or the team's work is so predictable that the allocation is not providing decision value. Consider reducing cadence. |
| Commit counts or lines of code are used as effort proxies | Someone automated the allocation using code-level metrics. | Replace with person-day estimates. A 3-line config change that took 2 days of investigation is 2 person-days, not 3 lines. A 500-line generated migration is not 500 lines of investment. | The automated proxy is being used in executive reporting. Escalate immediately -- the numbers will mislead. |
| Cross-team rollup double-counts shared work | Platform team and consuming team both claim the same effort in their allocations. | Enforce the attribution rule: one team owns the effort, the other references it via the cross-team attribution row. | Double-counting persists after one quarter. Escalate to the leader who owns the rollup and agree on a single attribution convention. |
Explicit limitations
- This method does not produce financial numbers. Person-days approximate where time went. They do not account for salary differences, contractor costs, tooling spend, or opportunity cost. If finance needs dollar figures, they must apply their own cost model to your allocation -- and you should insist that the uncertainty is preserved when they do.
- Mixed-purpose splits are judgment calls. A 70/30 split on a single item is defensible. Aggregating hundreds of judgment-call splits does not magically produce precision. The aggregate is directionally useful, not exact.
- Non-code work estimates are rough. Time spent in code review, meetings, Slack, and investigation is difficult to measure without time-tracking tools, and time-tracking tools create their own distortions. Estimate honestly, accept the imprecision, and keep the unknown bucket visible.
- The method does not tell you the right allocation. There is no universal correct split between new capability, reliability, maintenance, and support. The right allocation depends on your product stage, reliability posture, tech-debt load, and customer commitments. This worksheet helps you see where you are. Strategy tells you where you should be. The gap between the two is where the conversation starts.
- Allocation does not measure value. A team that spends 60% on new capability might ship features nobody uses. A team that spends 40% on reliability might prevent outages worth millions in retained revenue. The allocation tells you about inputs, not outcomes. Pair it with outcome metrics to make it useful.
- Categories are not natural kinds. The four-category framework (new capability, reliability, maintenance, support) is a useful simplification, not a discovery about the structure of engineering work. Some teams will need a fifth category (e.g., "experimentation" or "platform"). Others will find that "maintenance" and "reliability" blur together. Adapt the categories to the decisions your organization actually makes; do not preserve them out of loyalty to the template.
- Retroactive reclassification has limits. Allowing unlimited re-classification erodes trust in the historical record. The quarterly-review-only rule described in the worked scenario is a compromise, not a perfect solution. If your team reclassifies more than 10% of effort in a given quarter, the original classification process needs tightening.
Ongoing review routine
Every sprint (or iteration):
- Fill out the worksheet. (15 minutes)
- Have a second person validate a sample of 5-10 items. (10 minutes)
- Note any new disagreements and update category definitions if needed.
Every month:
- Compare the last 2-4 sprints side by side. Look for trends, not individual data points.
- Check whether the unknown bucket is shrinking, stable, or growing. If growing, investigate why.
- Review the tradeoff observations section: are the decisions suggested by the allocation actually being made?
Every quarter:
- Present the quarterly aggregation to leadership with the confidence column and unknown bucket visible.
- Compare the actual allocation to any targets or intentions set at the start of the quarter. If they diverge, explain why -- do not just show the gap.
- Process any retroactive reclassifications. Document what changed and why. If reclassifications shift any category by more than 5 percentage points, show both original and revised figures.
- Review cross-team attribution rows across all teams in the rollup. Check for double-counting.
- Decide whether category definitions need revision. If a category is never used, merge it. If one category is too broad, split it.
- Archive the quarterly worksheet. You will want to compare year-over-year eventually.
Annual:
- Review whether the allocation exercise is still informing real decisions. If nobody references the data between reviews, either the data is not reaching the right people or the decisions it was meant to inform are being made on other grounds. Adjust or retire the exercise rather than continuing on autopilot.
For teams using FeatureFactory to examine delivery patterns, the allocation worksheet complements what you see in code-level data by adding the human judgment layer: why work was done, not just that it was done.
Next-action checklist
- Copy the worksheet template into your team wiki or shared doc.
- Schedule 15 minutes at your next sprint boundary to fill it in for the current sprint.
- Recruit one other person (tech lead, staff engineer, or peer manager) to validate a sample of 5-10 items.
- Run a single calibration round: present 3 ambiguous work items to 2 people independently, compare classifications, and refine your definitions.
- If your team produces shared infrastructure, agree on an attribution rule (producing team owns effort, consuming teams are annotated) and add the cross-team attribution row.
- Present the first completed worksheet to your team. Ask: "Does this match your intuition about where our time went?" Disagreements are useful data.
- After 2 sprints, present the side-by-side view to leadership with the unknown bucket visible and at least one tradeoff observation.
- Set a calendar reminder for quarterly review.
- After one quarter, decide whether the exercise is informing decisions. If not, diagnose why before continuing.
Measure what you ship - for real.
Put your team’s AI web-development on the outcome loop.
Get early access