We took apart a 120-person project burning 48 hours/week on pointless checks. In 6 months, cut costs 25% ($380k/year) without touching quality. Here's how we did it.
This isn't textbook theory. We grabbed payroll data, task times, Excel sheets, drew the value stream, found three major bottlenecks. Then eliminated them.
The Problem: 120 People Team + 48 Hours/Week Waste
Fintech project came to us for consulting. 120 people: 65 developers, 28 testers, 18 analysts, 9 production admins. $12M annual budget. Development cycle — 42 days from idea to production.
Classic symptoms: sprints burning, testers idle, analysts rewriting requirements 3x. Project lead felt money leaking but couldn't pinpoint where.
First step — calculated time waste. Collected 4 weeks data:
| Role | Waste Time/Week | Reason |
|---|---|---|
| Testers (28 people) | 24 hours | Waiting for code from developers |
| Analysts (18 people) | 12 hours | Rewriting requirements |
| DevOps (9 people) | 12 hours | Manual deployments |
Total: 48 hours/week × $75/hour = $144k/year waste on idle time alone. Real picture was 2.5x worse.
Client's main question: "Where exactly is money leaking and how do we stop it?"
Step 1. Mapped the Complete Value Stream
Gathered entire team for 2 days in Miro. Every process from "feature idea" to "production" went on color-coded sticky notes. Got 28 steps total, only 9 created real value.
What we mapped:
Green notes: value-adding (coding, test execution)
Yellow notes: necessary but non-value (code review, CI/CD)
Red notes: waste (3 levels doc approval, duplicate tests)
Final value stream: 28 steps breakdown:
- 9 steps (32%) — actually created value
- 12 steps (43%) — waiting (testers wait for code, DevOps waits approvals)
- 7 steps (25%) — pure waste (manual log checks, Excel reports)
Lead Time: 42 days total. Value-adding work — 8 days. Rest = transport + waiting.
Client looked at diagram and said: "Now I understand why we spend $12M and barely move."
Step 2. Identified 3 Major Bottlenecks
From 28 steps, we pinpointed three that choked the entire flow. Not where most people worked, but where work actually got stuck.
Bottleneck #1: Triple requirements approval (18 analysts)
Analyst writes spec → senior analyst reviews → tech lead approves. 68% got sent back for rework. Total: 12 hours/week rewriting.
Bottleneck #2: Testers waiting for code (28 people)
Developers delivered Friday 6PM. Testers saw code Monday 11AM. Idle time: 40 hours/week. Plus developers waited test results until Wednesday.
Bottleneck #3: Manual deployments (9 DevOps)
Each deploy: 27-point checklist, manual log checks, Slack notifications. 12 hours/week. 60% duplicated CI/CD checks.
We showed client: these three bottlenecks created 72% of all delays. Fix was simple — remove extra people, automate the rest.
Step 3. Redistributed Roles — Freed 18 People from Duplicate Work
First fix — killed triple spec approval. Left only analyst + tech lead (one reviewer policy). Saved 9 analysts who now join daily meetings to clarify requirements with teams.
Before: Analyst → senior → tech lead → 3 iterations → 4 days After: Analyst + tech lead → 1 iteration → 8 hours
Second: parallel testing. Developers push to QA environment immediately after merge to develop branch. Testers start same day. Idle time dropped from 40 to 6 hours/week.
Setup auto-deployment to QA on merge. Developers see smoke test results in Slack notifications themselves.
Third: DevOps checklist → automation. Replaced 27 manual points with 4 GitHub Actions:
Linter + security scan
Unit tests + coverage
Integration tests
Prod checklist (one-click approve)
9 DevOps shifted to infrastructure as code (IaC) and monitoring. Deployment time: 12 → 2 hours/week.
Redistribution result: 18 people (9 analysts + 9 DevOps) moved from paperwork to real work. No layoffs — just role realignment.
Step 4. Automated 40% Routine Checks
After role fixes, tackled automation. Core principle — remove humans from "check → approve → notify" loops.
Automation #1: Requirements workflow (n8n)
New spec hits Notion → auto-checks completeness (template + required fields) → tech lead gets Slack with approve button or fix list.
Time: 4 days → 4 hours. First-time approval: 92%.
Automation #2: Tests during development
GitHub Action on pull request → smoke tests in QA → results posted to PR comment. Developer sees "3/4 tests failed" before code review.
Production bugs dropped from 17% → 4%. Testers freed 22 hours/week.
Automation #3: Deploy notifications
Production deploy → auto: changelog to Slack, metrics to Grafana, stakeholder notification. DevOps spend 2 hours vs 12.
Total automated: 40% routine checks. Saved 28 hours/week just on notifications and approvals.
Results: -25% Costs, -18% Development Time
6 months later, team delivered results that nearly knocked client off his chair. Calculated honestly: payroll, time saved, development cycles.
| Metric | Before | After | Change |
|---|---|---|---|
| Annual Costs | $12M | $9M | -25% |
| Dev Cycle | 42 days | 34 days | -18% |
| Prod Bugs | 17% | 4% | -76% |
| Team Idle Time | 48h/week | 8h/week | -83% |
Key insight — savings didn't come from layoffs. Same payroll. Just moved 18 people (9 analysts + 9 DevOps) from paperwork to real work: analysts clarify requirements in dailies, DevOps build infrastructure as code.
Client said: "I budgeted for 15% team growth. You optimized without cuts." Now they deliver +2 features/quarter vs 1 before.
5 Lessons We Learned: Rules for Your Team
6 years consulting 127 projects. Here's what always works:
Draw value stream quarterly. People change, processes drift. No map = flying blind.
Bottlenecks aren't where most people work. 18 analysts weren't the problem. Triple spec approval was.
Automate approvals, not just code. n8n + Slack = 40% routine gone. GitHub Actions = 30% more.
Parallel testing saves 40h/week. Code hits QA on merge. Smoke tests in PR. Devs check themselves.
One reviewer policy works. Tech lead vs 3 approval levels. Specs done 8 hours vs 4 days.
Want this value stream for your project? Reach out and we'll draw it in 2 days. Miro template is ready.
Get Consultation