---
title: "Engineering team design for autonomous delivery | QMates"
source: https://qmates.tech/en/services/engineering-transformation/engineering-team-design
description: "Engineering team design that starts from the code: Team Topologies, Conway's law and clear ownership, so each of your teams can release on its own."
updated: 2026-11-20
---

# Engineering team design: teams that release without waiting for each other

How your engineering teams are organised decides how much work reaches production and how much sits waiting for another team. We work with CTOs, engineering managers and teams to redesign that structure together with the code those teams change every day. Organisation and architecture constrain each other, so if you change only one, the other pulls it back to where it was.

## When should you rethink how your engineering teams are organised?

When time is lost in the handovers between teams. You will usually notice it from signs like these:

-   An ordinary feature needs work from three teams, and each waits for the others before releasing
-   You have hired, yet you ship less than before
-   The stand-up or the cross-team meeting mostly exists to sync dependencies
-   Several teams change the same modules, and merge conflicts and regressions are routine
-   A reorganisation a year ago changed the org chart, but the way work moves through the code stayed the same

## What do we do?

We read your teams, code and domain together, propose a new organisation and stay with you while you put it into practice. As we redesign the teams we also work on the architecture, and every step on one takes the other into account.

### We map the domain before the teams

A team structure holds when team boundaries match real boundaries in the product. To find them we start by mapping the domain with [Domain-Driven Design and EventStorming](https://qmates.tech/en/services/engineering-transformation/domain-driven-design-event-storming). The bounded contexts that emerge are the first candidates for a team's area of responsibility.

### We find where the organisation weighs on the code, and the code on the organisation

From your version control history we reconstruct which teams change which modules, how many components have to be touched to release a feature, and where work sits idle waiting for another group. Fragmented ownership of a component, meaning several teams changing it with nobody answerable for the whole, is where coordination cost and technical debt grow together. Organisational code ownership is the metric that makes it visible.

### We propose the new organisation

Building on that reading, we design the target organisation with you. We use whatever fits your case: the team types and interaction modes of Team Topologies, feature teams that carry a feature from idea to production, and the inverse Conway manoeuvre, when it makes sense to design the teams first so that the architecture you want follows from them. The result is a proposal that says which teams you need, which part of the system each one is responsible for, how they interact and in what order you get there.

### We support the change, in the code too

A reorganisation has a cost: friction, learning curves, weeks when everything moves more slowly. So we take it step by step, starting where waiting between teams costs most. Meanwhile we work with the teams on the code, so that the new boundaries become technical boundaries, with clear module ownership, explicit contracts between parts and independent releases.

### Coaching for managers and tech leads

The people who lead the teams need to be able to run the new organisation once we are gone. We work alongside engineering managers, tech leads and product managers, with coaching sessions on the decisions they will face. How do you form and split a team? When should a dependency be removed, and when managed? How do you spot drift before it turns into another reorganisation?

## How do we work with your team?

The decisions about the organisation stay with you, and so do the people who make it work. We bring the method and work beside whoever applies it. You can ask us for just the proposal for the new organisation and the coaching for managers. We advise adding work on the code alongside the teams, because releases are where you see whether the new organisation holds. When the change calls for working side by side every day, our presence in the teams takes the form of [Embedded Teams](https://qmates.tech/en/services/engineering-transformation/embedded-teams).

## What do we measure to find our bearings?

Wherever possible, we steer by measurement. Where the data is missing, we describe the systemic effects we observe and the factors worth looking into. We measure the flow of work between teams and never assess individuals. The DORA metrics, cycle time and lead time across the whole cycle, and value stream mapping, which shows where a request waits in a queue between one team and another, are some of the metrics and techniques we use to guide continuous improvement. Alongside these we look at measures that link organisation and code: how many components are touched for one feature, how fragmented the ownership of each module is, and how often a team has to wait for another before it can release.

## What changes for the team and the product?

The amount of coordination needed to get a feature into production goes down. A team with a clear area of responsibility releases without asking three other groups for permission, so delivery becomes more predictable and estimates start to mean something again. New hires join a team with readable boundaries and don't slow down the people already there. Management stops acting as a switchboard between teams and goes back to deciding where to invest. With an owner for every part, the code stops accumulating the debt that comes from cross-team changes.

## Where do you start?

You can start right here, with a first reading of your teams and code. If you don't yet know whether the bottleneck lies in the organisation, the code, the practices or the release flow, we suggest beginning with the [Software Delivery Assessment](https://qmates.tech/en/services/engineering-transformation/software-delivery-assessment), which looks at all four levels and tells you where to intervene first.

## Related services

-   [Domain-Driven Design and EventStorming](https://qmates.tech/en/services/engineering-transformation/domain-driven-design-event-storming) – the domain mapping that team boundaries come from
-   [Embedded Teams](https://qmates.tech/en/services/engineering-transformation/embedded-teams) – senior developers inside your teams while the new organisation takes shape
-   [Software Delivery Assessment](https://qmates.tech/en/services/engineering-transformation/software-delivery-assessment) – to find out first whether the bottleneck lies in the organisation

## Frequently asked questions

What is Conway's law, and why does it matter for team organisation?

Conway's law, formulated by Melvin Conway in 1968, observes that a system ends up mirroring the communication structure of the organisation that builds it. For anyone leading engineering, this means the boundaries between teams become boundaries in the software, with their gaps and friction. Every decision about team structure is therefore also an architecture decision, whether you intend it or not.

What is the inverse Conway manoeuvre, and when is it worth using?

It means designing first the team boundaries you want to see reflected in the software, so that the architecture you want follows from them. Team Topologies popularised it. It is worth using when the diagnosis shows that teams and architecture are misaligned and working on the code alone is not enough, because the dependencies re-form every cycle. The decision should rest on data and be taken with the transition costs in view, since reorganising teams has a price in friction and learning.

Do we have to adopt Team Topologies in full?

No. Team Topologies offers a useful vocabulary, with team types and interaction modes, and we use it where it helps make explicit who does what for whom. What matters is that each team has a clear area of responsibility and can release independently, whatever the model is called.

Feature teams or component teams?

It depends on where the boundaries of your product lie. Feature teams own a feature end to end, without handing it to another group halfway, and they work well when the domain can be split into independent areas. Where part of the system needs very specialised skills, a team dedicated to that part can reduce the load on the others, provided its service to the other teams is explicit.

Can you change the organisation without touching the architecture?

You can, but it usually doesn't last. If the code still forces three teams to change the same modules, the dependencies come back whatever the org chart says. That is why we recommend supporting the new organisation in the code too, until each team fully owns the part of the system entrusted to it.
