Software delivery assessment: the bottlenecks slowing you down and a plan to clear them

The Software Delivery Assessment is a one- to two-month analysis that looks for the bottlenecks in your software development at five levels: code, practices, process, organisation and the way your team uses AI. At the end we hand you a document with your starting position, the bottlenecks we found and our recommendations, plus a first outline of a recovery plan, which we talk through with you in a review meeting.

It fits teams that work hard and ship little, where nobody can say for certain where the time goes.

Book a call

Why does your team ship more slowly than it could?

Time is often lost between one step and the next, where code, practices, process and organisation have stopped evolving together and every change waits longer than it should before reaching production. You can spot it from signs like these:

  • Estimates slip every sprint and the roadmap keeps moving
  • A small feature means touching several modules and coordinating several teams
  • Finished work sits waiting for a review, a manual test or a release window
  • You've hired more developers and speed has stayed the same
  • Bugs reach production, and fixing them eats into new work
  • You've given the team AI assistants and agents, and releases haven't become more frequent

The last sign is easy to misread, because AI speeds up writing code while the rest of the cycle stays as it was. Google Cloud's 2025 DORA report, based on almost 5,000 professionals, describes AI as an amplifier of whatever an organisation already is, weaknesses included. If work already waits at the steps listed above, code written faster only makes the queue longer.

What do we analyse?

We analyse five levels of your software development and, above all, the places where one level slows down another.

Code and architecture

We read the code to see what it costs to change: how many modules a typical feature touches, which parts change most often, where the tests that make a change safe are missing. We stop at what weighs on speed. The full map of your debt, with priorities for action, is the job of the Technical Debt Assessment.

Development practices

We watch how the team writes, verifies and integrates code: automated tests and TDD, pair programming, reviews, the size of changes, how often work is merged into the main branch. These practices determine how long it takes for a change to go from written to released.

Process and flow of work

We follow work from idea to release: how the backlog is built and prioritised, how planning is done, how many items are open at once, where work waits for a decision, an environment or an approval. We also look at the pipeline and the infrastructure, because a manual release or a slow build sets a ceiling that no effort from the team can lift.

Team organisation

We map how teams are split across the code and the product, who sets priorities and how many teams it takes to get a feature into production. Dependencies between teams are a cost that appears in no estimate, yet it grows every time the organisation adds people.

AI use in the team

We look at who uses assistants and agents, for which tasks and under what rules, how generated code is reviewed and how many tokens are spent. Each developer has often built a method of their own, and comparing them shows whether AI is speeding up the point where work stalls or one that was already fast.

The most useful work happens where the levels meet, so we compare who owns each module with how the teams are structured. A module that many people change and nobody owns piles up complexity and slows everyone who touches it. A code boundary that cuts a team in half forces it to coordinate more than it should. This is Conway's law observed in your repository, and it is where we look for the part of the slowdown that no single level shows on its own.

How does it work?

It takes one to two months, depending on the size of the organisation, and sets what people tell us against the data.

We interview the people who run the company and the product, the technical leads and the developers, and we send the team a short survey. Meanwhile we read the code and hand our AI agents the data your development leaves behind: code and commit history, releases, infrastructure, the backlog and project management tools, token usage. The agents point us to where to look, and we check what they find by reading the code and talking to the team. We work with the stack and tools you already have.

Interviews, survey and data come from different sources and sometimes disagree, and the gap between what management believes and what the team experiences is the most useful finding. We start from the problems you feel yourselves, because that is where change finds support, and then widen the view to the ones nobody has named yet.

  1. 01

    Scope and access

    We choose with you the teams and products to observe, get access and schedule the interviews.

  2. 02

    Data gathering

    Interviews, survey, code reading and agent analysis run in parallel.

  3. 03

    Review with the team

    We test our hypotheses with the people who work in the code every day, before writing them up.

  4. 04

    Document and review meeting

    We write the document and talk it through with you.

What do we measure?

We measure how long work takes to cross the whole cycle and where it stops. These are some of the metrics and techniques we use to guide continuous improvement:

  • DORA metrics – deployment frequency, lead time for changes, change failure rate and time to restore service
  • Cycle time and lead time across the whole cycle – from the moment an idea enters the backlog until it reaches users, because part of the wait can come before a line of code is written
  • Value stream mapping – we chart the steps of the work and separate the time someone spends on it from the time it sits waiting
  • People time and tokens spent – how much effort, and how much AI, it takes to get a feature into production

The measures describe the flow of work and of teams and never assess individuals. They become the baseline for comparing the months that follow. Wherever possible, we steer by measurement. Where that isn't possible, we describe the systemic effects we observed and the factors that need a closer look.

What do you receive?

A written document and a review meeting where we discuss it with the people who have to decide.

  • Your starting position – how you work today at each of the five levels, with baseline measures
  • The issues we found – the bottlenecks, ranked by how much they weigh on speed, with the facts behind them
  • Recommendations – what to try and what to avoid, including changes that look useful but would cost more than they return in your context
  • A preliminary outline of a recovery plan – where to start, in what order to proceed and which signals to watch to tell whether it's working

The plan stays preliminary on purpose, because it takes shape once you decide who carries it out and on what timeline. We prefer to hold the review meeting in person, and remotely if needed. A document read alone leaves questions that a meeting can answer on the spot.

What happens after the assessment?

The document is yours, and your team can follow the plan on its own. If you would rather have support, the plan shows which services address the issues we found, and in what order.

If the change touches several levels at once, Embedded Teams brings full-time QMates developers into your team.

Frequently asked questions

How is it different from the Technical Debt Assessment?
The Technical Debt Assessment looks at the code and delivers a debt map with priorities and a 90- and 180-day plan. The Software Delivery Assessment looks at code, practices, process, organisation and AI use to find where work waits, from backlog to production. When the bottleneck turns out to be in the code, the two complement each other.
How does it differ from the AI assessment for software development?
The AI assessment for software development is done before introducing AI into development and measures the starting point. This assessment is for when speed is below expectations, with AI or without it, and as far as AI is concerned it looks at how the team uses it today and whether it speeds up the very phase where work slows down.
We've introduced AI in the team and we aren't releasing more often. Where do we start?
You start by measuring the whole cycle, because the time gained writing code can be lost in the waits that come afterwards. In Atlassian's 2025 State of Developer Experience report, covering 3,500 developers and managers, 68% say AI saves them more than ten hours a week and 50% say they lose ten or more, largely to organisational inefficiencies. These are self-reported figures, collected by a company that sells developer tools, but they point the same way as the 2025 DORA report.
How long does it take?
One to two months, depending on how many teams and products are in scope. The time is needed to observe the flow of work on real data and to listen to everyone involved.
What access do you need?
The repository and its history, the release pipeline, the backlog and project management tools, and usage data from AI tools. We agree the scope and the rules on data use with you before we begin.
Do we have to start with the assessment to work with you?
No. It is the starting point we recommend when it isn't clear where to intervene. If the bottleneck is already obvious, you can start directly with the service that addresses it.

Let's talk about where your development stalls

We start with a call. You tell us the symptoms, and we tell you whether you need the assessment and with what scope

We use your data to respond to your request. Read our Privacy Policy.