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:

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.

Where a slipped two-week feature actually spent its time Illustrative trace of one delayed feature commitment across 112 elapsed working hours: 14 hours of active coding, review, and deploy work compared with 98 hours of waiting for product scope answers, reviewer pickup, and release sign-off. Why totals lie: active work vs waiting in a slipped feature Illustrative work-trace format (hours elapsed across 14 working days) 1. Coding 9h active 2. Scope hold 32h waiting on founder / PM decision 3. Review pickup 28h unassigned PR queue 4. Code review 3h active 5. Release gate 2h deploy + 38h waiting for manual staging batch Blue = active engineering effort (14h). Orange/Red = queue and decision wait (98h).
Asking developers to code 20% faster saves less than two hours on a ticket that spent 98 hours waiting.

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:

  1. When this item paused on Tuesday, what decision were you waiting for, and who had the authority to make it?
  2. Which part of the codebase or release process makes you nervous to deploy on a Friday?
  3. 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:

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:

FieldIllustrative Diagnostic Entry
Observed symptomOnboarding PRs sit 40+ hours before first human comment.
Evidence in sample5 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 testCap non-generated PRs at ~250 lines, assign a rotating daily triage reviewer, and pair-review auth touches.
Named owner & tradeoffBackend lead runs the 2-week trial; founder defers one internal admin feature to free 4 hours/week of pairing.
Success check at Day 30Pickup 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:

The Day 10 Teardown Handover Structure Three operational buckets delivered on Day 10: work to pause immediately to free capacity, 3 to 5 prioritized 30-day interventions with named owners and metrics, and larger structural or hiring changes deferred until flow stabilizes. 1. STOP THIS WEEK Free capacity first • Pause zombie projects • End Slack scope swaps • Freeze unvetted tools Owner: Founder / CEO 2. FIX IN DAYS 1-30 3-5 bounded fixes • One owner per stall • Review SLA + PR cap • Weekly check + guard Owner: Eng & Product 3. DEFER PAST DAY 30 After flow stabilizes • Squad topology splits • Permanent exec search • Large re-architecture Trigger: Day 30 review
Every 30-day fix names the work you stop to fund it.

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:

  1. 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.
  2. Tool migrations. Ripping out Jira for Linear or switching CI vendors in week two burns political capital while leaving the underlying approval bottleneck intact.
  3. Org-chart reshuffles. Moving boxes around before you clarify decision rights just creates the same confusion inside new Slack channels.
  4. 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: