Engineering Org Teardown: My First Two Weeks
TL;DR
- Don't reorganize blind. Most slipped roadmaps come from waiting time, unclear review ownership, or founder bottlenecks, not lazy engineers.
- Trace real items end to end. Follow 6 to 10 recent promises from ticket creation through review, merge, release, and production support, including abandoned work.
- Measure the phases, not just the total. LinearB's 2026 study of 8.1 million PRs puts 75th-percentile elite cycle time under 25 hours, yet AI-generated PRs wait 4.6x longer for review (LinearB, 2026).
- Leave with a 30-day plan. Day 10 ends with named owners, explicit capacity tradeoffs, and clear validation checks, plus a short list of things I leave alone.
Your roadmap keeps slipping. Product says engineering pads estimates and still misses dates. Your senior engineers say priorities change mid-sprint, while you spend Tuesday nights triaging escalations and unblocking scope fights yourself.
At that moment, founders reach for one of three expensive levers: hire a permanent VP Engineering, reorganize the squads, or buy a velocity dashboard. Every one of those bets costs months if you misdiagnose the constraint.
Engineering org teardown is a bounded two-week diagnostic that maps where delivery stalls, who actually makes decisions, and what operational risks sit open before you change the org chart. Below is how I run those first ten working days, what I inspect, and what I leave untouched.
Day 1: set the mandate, access rules, and trust boundaries
Day one starts with the founder and whoever leads engineering today, before I open a single repository. If you ask for a broad audit to "see how engineering is doing," you get an interesting document that changes nothing on Monday morning.
Instead, write down the exact business decision the teardown must support. You might ask why onboarding releases slip by three weeks, whether one engineer is a single point of failure, and what has to wait next month.
Once that question is sharp, lock five rules in writing:
- Scope: Name the product area, teams, and 60-to-90-day window under review, alongside what stays out of scope.
- Decision rights: Clarify that during a diagnostic I recommend changes rather than silently reprioritizing sprints, unless we explicitly pair the teardown with an interim mandate.
- Confidentiality: Agree who sees raw interview notes versus the final readout. Individual contributors speak honestly only when they know how attribution works.
- Access: Keep permissions narrow. Following NIST's least-privilege principle, I ask for time-limited, read-only access to Git history, CI runs, issue trackers, and redacted incident postmortems. Production secrets and live customer records stay off limits.
- Calendar holds: Book the individual interviews and the Day 9 team challenge session on Day 1 so the schedule does not drift into week three.
Agreeing these rules takes two hours. Skipping them costs you the trust of the engineers whose evidence you need on Day 3.
Days 2 to 3: trace real work from promise to production
On Day 2, I pull a sample of six to ten recent work items with product and engineering, then trace each one from initial promise to customer impact. Self-reported speed misleads everyone involved. In METR's controlled study, experienced developers took 19% longer with AI tools while believing they had moved 20% faster (METR, 2025).
Because memory flattens waiting time, I sample across four buckets: one shipped feature that went smoothly, two delayed roadmap commitments, at least one abandoned branch or killed ticket, and two recent incidents or hotfixes. Looking only at merged tickets hides the weeks your team burned on work that never reached a user.
Delivery cycle time is the elapsed time from a developer's first commit to code running in production, broken into coding, review pickup, review approval, merge, and deploy phases. LinearB's 2026 Software Engineering Benchmarks Report, covering more than 8.1 million pull requests across 4,800 teams, puts 75th-percentile elite cycle time under 25 hours and elite review pickup under 1 hour (LinearB, 2026). Meanwhile, AI-generated pull requests wait 4.6x longer before review starts, and agentic PRs sit 17.6 hours waiting for pickup versus 3.4 hours for unassisted code.
When you separate active work from waiting, the conversation shifts immediately. A four-day delay in review pickup needs explicit reviewer routing and smaller batch sizes, whereas a four-day delay after merge points straight to release automation. If you want the exact gh and GitLab CLI queries I use to pull those timestamps without buying a platform, grab them from my breakdown of the METR productivity data.
Days 3 to 5: interview separately and map founder bottlenecks
Once I have timestamps on six real tickets, I interview the founder, the product lead, managers, and individual engineers separately. Group retrospectives soften the sharpest truths because nobody wants to say in front of twelve peers that the CEO rewrote the spec on Thursday afternoon.
I put the same sampled tickets on the table in every room and ask three concrete questions:
- When this item paused on Tuesday, what decision were you waiting for, and who had the authority to make it?
- Which part of the codebase or release process makes you nervous to deploy on a Friday?
- What unplanned work interrupted your week that never showed up on the sprint board?
On Day 5, I compare those answers against your roadmap commitments and actual team capacity. Founder bottleneck is an operating pattern where ambiguity in product scope, architecture sign-off, or incident escalation routes back to one founder or tech lead, starving the rest of the org of decisions.
You can spot this pattern in thirty minutes once you map commitments against uninterrupted hours. Account for on-call load, customer support escalations, hiring interviews, security questionnaires, and maintenance before you allocate anyone's week to new features. Often one staff engineer is listed as technical lead on two urgent bets while also acting as the sole reviewer on billing or permissions.
Additionally, check where product specs end and engineering guesses begin. As I wrote in Shift-Up Engineering, IDC data shows developers spend roughly 16% of their week writing code while the remaining 84% goes to requirements, testing, security, and delivery plumbing. When product ambiguity arrives in Slack mid-sprint, engineers become blocked runtime dependencies.
Days 6 to 8: inspect pipeline risk and test competing explanations
On Day 6, I follow the delivery trace into your infrastructure, CI/CD pipeline, and incident history. Two weeks is too short for a line-by-line audit of your entire codebase, and anyone promising that in ten days is skimming. Instead, I inspect the exact components where your sampled tickets stalled or broke in production.
With an engineer sharing their screen, I check four operational realities:
- Bus-factor deploys: Can a second engineer ship and roll back the core service without the usual author online?
- Pipeline friction: How long does CI take from push to green, and how often do flaky tests train engineers to click re-run until it passes?
- Incident loops: Looking at your last three customer-facing incidents, did the postmortem produce a code or pipeline guard, or just a promise to "be more careful next time"?
- Compliance and buyer blockers: If you sell into Europe, do your actual data flows, audit logs, and deletion paths match what sales promised in procurement? When EU deals are part of the mandate, I cross-check against the 90-day EU readiness sequence.
In my experience stepping in as interim Head of Engineering at an automotive corporate startup with 11 engineers, 2 PMs, and 2 QA working under ASPICE, deploys to internal integration happened roughly once a month. Engineers were already writing code with Claude Code, yet delivery felt stuck. When we built a real CI/CD pipeline and placed an automated review gate in front of human reviewers, integration deploys moved to roughly twice a week.
Most of that gain came from fixing the pipeline and writing down code standards, rather than from the coding assistant. I break down the financial side in my honest AI coding assistant ROI model and Google DORA's 2026 report summary. DORA models a 15% initial capacity dip when teams pour extra code into slow review pipelines (Google DORA, 2026).
On Days 7 and 8, I write every candidate diagnosis as a falsifiable card so we don't jump to the wrong cure. Here is an illustrative finding card showing the exact structure I hand over:
| Field | Illustrative Diagnostic Entry |
|---|---|
| Observed symptom | Onboarding PRs sit 40+ hours before first human comment. |
| Evidence in sample | 5 of 7 sampled PRs waited 2 working days unassigned; median diff was 620 lines. |
| Hypothesis A (process) | Nobody owns first-response review routing on cross-squad changes. |
| Hypothesis B (architecture) | Onboarding touches shared tenant-auth code that only one senior engineer understands safely. |
| 2-week validation test | Cap non-generated PRs at ~250 lines, assign a rotating daily triage reviewer, and pair-review auth touches. |
| Named owner & tradeoff | Backend lead runs the 2-week trial; founder defers one internal admin feature to free 4 hours/week of pairing. |
| Success check at Day 30 | Pickup time drops under 8 hours without raising revert or hotfix count. |
Notice why testing both explanations matters. If you add a Slack reminder bot when the real issue is terrifying auth coupling, your senior engineer just gets pinged faster while remaining the sole bottleneck.
Days 9 to 10: challenge the findings and hand over the 30-day plan
On Day 9, before I sit down with the founder for the final decision meeting, I walk the engineering and product contributors through the factual evidence. That step catches missing context early and separates a disputed opinion from a wrong timestamp.
Engineers don't get a veto over business priorities; those belong to the founder. However, letting the team challenge the evidence ensures nobody walks into Monday's planning session blindsided by a consultant's slide deck.
On Day 10, I hand over a written decision memo and evidence register built to run without me in the room:
A plan with twelve priorities is a wish list. In a 15-to-80-person company, an engineering org can absorb three to five operational changes in a month while still shipping customer commitments. Every item on the 30-day list carries a single accountable owner, the existing commitment you will pause to fund the work, and the exact signal you will check two and four weeks later.
What I deliberately leave alone in the first two weeks
Half the value of a senior operator in a short diagnostic is knowing what not to break while gathering facts. Unless I uncover an active outage, leaked credentials, or an immediate data-loss hazard, I leave four things untouched during those ten days:
- Individual performance rankings. Commit counts and PR totals reward noisy activity and punish the engineer quietly untangling gnarly incidents. Ten days is far too short to grade individuals fairly.
- Tool migrations. Ripping out Jira for Linear or switching CI vendors in week two burns political capital while leaving the underlying approval bottleneck intact.
- Org-chart reshuffles. Moving boxes around before you clarify decision rights just creates the same confusion inside new Slack channels.
- Cosmetic agile rituals. Adding daily standups or story-point poker rarely fixes a team whose real problem is unowned product specs or a forty-minute test suite.
Once the 30-day plan is on the table, you face one clean choice. Often your existing tech lead or engineering manager can execute the roadmap as soon as you clear the competing priorities and stop routing decisions around them.
When nobody in-house has the scar tissue or calendar room to run that plan, you need senior coverage while you build toward a permanent hire. Before you write that job description, read Fractional CTO vs Interim VP Engineering so you buy the exact mandate that matches your gap. You can also see how I work on my about page or as an interim and fractional CTO in Berlin.
If your roadmap is slipping and you want evidence before your next leadership hire or reorganization, Book a 30-minute readiness teardown.
Frequently Asked Questions
What is an engineering org teardown?
An engineering org teardown is a time-boxed, evidence-led diagnostic of how your team turns product commitments into running software. Across ten working days, it traces real tickets, code reviews, CI/CD pipelines, incidents, and decision rights to produce a prioritized 30-day action plan with named owners.
How much founder and engineer time does a two-week teardown take?
Expect roughly two hours from the founder on Day 1 and Day 10, plus 45-minute 1-on-1 interviews with five to eight people across product and engineering during Days 3 and 4. On Day 6 and Day 9, engineers spend another one to two hours walking through deployment pipelines and challenging the draft findings before final handover.
What access do you need to run the diagnostic?
Time-limited, read-only access to your issue tracker, Git metadata, CI/CD build history, architecture docs, and redacted incident postmortems covers nearly everything. Production credentials, customer databases, and secret stores stay out of scope, using screen-shared walkthroughs whenever live operational checks are needed.
What happens after Day 10 if we don't have a VP Engineering?
First, check whether an existing engineering manager or tech lead can own the 30-day plan once the founder removes competing priorities. If a true leadership gap remains, you can bring in an embedded interim leader two to five days a week to run execution and hire their permanent replacement.
Sources:
- LinearB, "Software delivery: find the phase where work stops (2026 Software Engineering Benchmarks Report, 8.1M+ PRs across 4,800 teams)," retrieved 2026-11-15, https://linearb.io/library/software-delivery
- METR, "Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity," July 2025, retrieved 2026-11-15, https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/
- Google Cloud DORA, "The ROI of AI-assisted Software Development," 2026, retrieved 2026-11-15, https://services.google.com/fh/files/misc/dora-roi-of-ai-assisted-software-development-2026.pdf
- NIST Computer Security Resource Center, "Least Privilege," retrieved 2026-11-15, https://csrc.nist.gov/glossary/term/least_privilege