arrow_back All posts
Our Journey to AI-Driven Development · Part 7

Pods: Three People, a Team of Agents, and a Rotation Through the New Platform

Agents changed what one person can own, so we changed the shape of the team. Pods of feature owner, developer and QA, rotating every two months so every developer works on the greenfield platform.

Daniel Wiedenhofer · Healy Hudson Portugal
· 9 min read

The first six parts of this series were about code, agents and pipelines. This one is about people, because at some point the agents changed what one person could own, and the team structure we had was built for a world where that was not true.

What we had

Until mid-2026 the product organisation looked the way most software companies look: a team per product, a team lead per team, developers and testers who belonged to one product and mostly stayed there. The open ordering team sat in Lisbon and Wiesbaden. The Impact Ordering team sat in Kaiserslautern. Each knew its product deeply and the other product hardly at all.

Then veenion one started, a greenfield platform meant to replace both legacy products one capability at a time. Staffing it the old way would have meant one of two bad options: pull the best people off the legacy products and leave those products hollow, or hire a third team that knows neither product and will spend a year learning what the migration has to preserve.

What a pod is

A pod is three people: a feature owner, a developer and a QA. That is the whole delivery unit. The feature owner is always a developer and is promoted from within the pod, so the person who owns the outcome is also a person who understands the code. The QA owns the gates and the tests, which in an agentic workflow is a far bigger job than it used to be, because the agents produce tests at a rate nobody can read by hand. The developer orchestrates the agents.

Three people is not a magic number. It is the smallest unit that still has a separation between the person who writes, the person who tests and the person who decides. Below three, someone approves their own work, and we spent part three explaining why we do not let agents do that either. Above three, the coordination cost starts to eat the speed the agents give back.

The reason three people can carry what used to need eight is sitting around them: the agency. The Architect, QA and Security reviewers, the implementing agents, the orchestrator, the skills and the module guides. A pod is three people plus a team of agents. The assessment scheme from part six has a dimension for exactly this, "small context teams of product owner, developer-orchestrator and QA", and the pod is our answer to it.

The rotation

The second idea matters more than the first. Pods are not fixed. People rotate through them in rings, and the new platform is a station on every ring.

A developer in a legacy maintenance pod moves to a veenion one pod, works there for a stretch, and returns to a maintenance pod carrying what they learned about the platform that will one day replace the product they maintain. Over the eighteen months of the plan, every developer spends between five and eleven months on the new platform. The rule in the plan is one sentence: "Every developer takes part in the new development."

The mechanics are designed to keep pods stable while people move:

  • Each person stays two months per station.
  • Developers rotate in even months, QA in odd months, so a pod never loses its developer and its tester at once.
  • Pods work in four-week cycles anchored to ISO calendar weeks, deliberately not calendar months, so the cadence does not wobble.
  • A second-level support pod per legacy product is staffed week by week by one developer, so interruptions have a home and the delivery pods are protected from them.
  • Maintenance pods pair a senior with a junior, which is where most of the knowledge transfer actually happens.

Each legacy product keeps a steering seat, the former team lead, for escalation and capacity. Architecture, UX, product ownership and leadership sit in a cross-cutting staff group rather than in any one pod.

The ramp

The pilot pod formed in July 2026. A new seating plan followed in September, and the first rotation round in October. Two pods work on veenion one today. In spring 2027 a second legacy maintenance pod converts into the third new-platform pod, and in autumn 2027 another converts into the fourth. By then each legacy product runs on one maintenance pod and one second-level pod, and four pods build the future.

The plan covers twenty-six people across Kaiserslautern, Lisbon and Wiesbaden, nineteen of them in the rotation. It also found a gap: twenty seats a month and nineteen people to fill them. That gap is a hiring position, and if you are reading this on our engineering page, it may be yours.

What it costs

The plan is honest about the price. Its own words: "Monthly rotation buys spread at the price of disruption." Every rotation means a person who has to find their feet in a different codebase, a different pod, sometimes a different city's rhythm. We chose spread anyway, because the alternative is a company where three people understand the new platform and twenty understand the old ones, and that is how migrations die.

The plan also names the precondition without which it fails. In translation: "without solid documentation, tests and a clean onboarding per pod, this grinds to a halt." That sentence is the reason parts two and four of this series exist. The module guides, the decision records, the governance tests, the onboarding workflow: they were written so that agents could work in our codebases. It turns out they are exactly what lets a person move between pods every two months and be useful on day three. The agents and the people need the same thing, and we only had to build it once.

A planner that still runs in five years

Someone has to keep track of who sits where, in which role, for which weeks, with absences overlaid and warnings when a pod is missing a role or has lost half its capacity. We built a small web application for that: Node and Express, a single HTML page with no build step and no frontend dependencies on purpose, so that it "still runs in five years", with the plan stored as one JSON document and absences pulled from our leave system. It has a drag-and-drop rotation view, a person-by-period matrix and an audit log. It took a few days. Most of it was written with agents, which felt appropriate.

What this means if you join

You will not be hired into a product. You will be hired into a rotation. Within your first year you will have worked on a legacy platform with twenty years of history and on a greenfield platform designed for agents, in a pod of three where your decisions are visible and your tests are the gates. You will be paired with someone senior, and later you will be the senior someone is paired with. If you want to specialise in one codebase for a decade, this is not the place. If you want to see how a migration is actually done, from both sides, it might be.

Coming next: our third codebase, sourcing, is still on Team Foundation Version Control. Part eight will cover its migration and the first agent-assisted tickets on it, as they happen.

Sound like your kind of engineering?