What a Pod Is

A pod is a team of roughly four to eight people that:

  • Owns an outcome, such as "checkout conversion" or "onboarding time", not a list of tickets.
  • Contains the skills to deliver it end to end: product, engineering, design, quality and data as needed, so it rarely waits on other teams.
  • Runs what it builds, including on-call and operations.
  • Is long-lived, so knowledge accumulates and ownership is clear. Pods are not assembled for a project and disbanded.
  • Has a clear boundary and interface to other pods and to the platform it builds on.

The model sits in a family of ideas: stream-aligned teams in Team Topologies (Skelton and Pais), product-aligned squads, and "two-pizza" teams. The names differ; the shared principle is to match team boundaries to the flow of value and keep each team\'s cognitive load manageable. Popular scaled frameworks built on similar ideas have also been criticised as copied without the culture that made them work, so treat any named framework as a source of ideas, not a blueprint.

Why Pods, and Why Now

  • Coordination is the bottleneck. As coding gets faster, handoffs, approvals and cross-team dependencies dominate lead time.
  • Agents shrink the build effort, so a small team can own more surface area, which makes broad ownership feasible without growing headcount.
  • Review, specification and judgement become the scarce skills, which favour small teams with deep context over large teams with narrow roles.

Evidence is mixed on how much agents change team size. Treat claims like "one engineer plus agents equals a team" as hypotheses to test with your own data.

Designing a Pod

Typical Composition

RoleResponsibilityNotes
Product ownerOutcome, priorities, customer contactMay be a senior engineer in small pods
Engineers (2 to 4)Design, build, review, operateMix of seniority; at least two who can review each other
DesignerExperience and researchShared between pods if necessary
Quality or test engineerTest strategy, evaluation suites, release confidenceBecomes more important as agents write more code
Data or analytics partnerMetrics, experiments, instrumentationOften shared
AI agentsImplementation, test generation, docs, triageOwned and supervised by named humans; they are tools, not headcount

Boundaries

Draw boundaries around user journeys or business capabilities ("payments", "search", "onboarding"), not technical layers ("frontend", "database"). Layered teams recreate the handoffs you are trying to remove. Test a boundary with one question: can this pod ship a typical change without another pod\'s code review or deployment?

Interfaces

Pods interact through versioned APIs, events and a shared platform, with published contracts and service-level expectations. Write down what a pod provides to others and what it expects, as a short document, not an organisation chart.

A Pod Charter

Every pod should have a one-page charter that is reviewed quarterly. Keeping it as a file in the repository makes it visible and diff-able:

pod: checkout
mission: Increase completed purchases while keeping payment failures under control
outcome_metrics:
  - name: checkout_conversion
    target: "+2 points this quarter"
  - name: payment_error_rate
    target: "< 0.5%"
owns:
  services: [cart-api, checkout-web, payment-adapter]
  oncall: checkout-oncall
  slos:
    availability: "99.9%"
    p95_latency_ms: 400
interfaces:
  provides: [Cart API v2, order.created event]
  depends_on: [identity-platform, payments-gateway, notifications]
people:
  product: a.rao
  engineers: [j.kim, s.okafor, m.silva]
  design: l.chen
  agents:
    - name: implementation-agent
      supervisor: j.kim
      scope: "feature branches in owned repos; no production access"
working_agreements:
  - Every change is reviewed by a human before merge
  - Agent-written code requires tests in the same pull request
  - Weekly demo to stakeholders; quarterly charter review
decision_rights:
  pod_decides: [implementation, internal architecture, sprint scope]
  escalate: [cross-pod API breaking changes, budget, security exceptions]

Notice the explicit agent scope and supervisor. Agents operating under a named human with a bounded scope are manageable; unowned agents with broad access are an incident waiting to happen.

Launching Pods in 30 Days

  1. Week 1: choose one pilot area with a measurable outcome, motivated people and manageable dependencies. Do not reorganise the whole company at once.
  2. Week 1: capture baselines for lead time, deployment frequency, change failure rate and time to restore (the four DORA metrics), plus the outcome metric.
  3. Week 2: write the charter with the pod, and list dependencies on other teams.
  4. Week 2 to 3: remove the top three blockers, for example access to production deployments, a shared review queue or an approval gate.
  5. Week 4: start a fixed cadence: planning, weekly demo, and a retrospective that looks at metrics, not just feelings.
  6. Day 30: review the baselines and the blockers. Decide whether to expand, adjust or stop.

Metrics

  • Outcome metric the pod owns (conversion, retention, time to first value).
  • Delivery metrics: lead time for changes, deployment frequency, change failure rate, time to restore.
  • Dependency wait time: days spent waiting on other teams. If this does not fall, boundaries are wrong.
  • Cognitive load indicators: on-call pages per person, number of services owned, onboarding time for a new member.
  • Quality of agent-assisted work: defects found after merge in agent-authored changes versus human-authored changes.

Avoid measuring individuals by lines of code or number of pull requests; with agents these numbers become meaningless.

Common Failure Modes

FailureSymptomFix
Pods in name onlySame shared backlog and approval chain as beforeMove decision rights to the pod and remove gates
Wrong boundariesEvery change needs another podRedraw around journeys; merge or split pods
Too many services per podConstant on-call fatigueReduce scope or invest in the platform
No platform supportEach pod rebuilds CI, deployment and observabilityBuild golden paths (platform engineering)
Agents without ownershipNobody reviews or understands agent codeNamed supervisor, tests, review rules (agentic workflow)
Knowledge silosOne person understands a servicePairing, rotations, written decisions
Re-organising too oftenPods never build contextCommit to at least a year for stable domains

When Pods Are the Wrong Answer

  • A small company with fewer than about eight engineers is already one pod.
  • Deep specialist work (kernel, compilers, research) may be better organised as a specialist team that serves others.
  • Highly regulated areas may need separation of duties that constrains "you build it, you run it"; adapt the model rather than abandon it.

Frequently Asked Questions

What is a pod in software development?

A pod is a small, long-lived, cross-functional team of roughly four to eight people that owns a product outcome end to end, from design and build to operation, with minimal dependency on other teams.

How is a pod different from a Scrum team or a squad?

The ideas overlap. A pod emphasises long-lived ownership of an outcome and a boundary drawn around a user journey or capability, plus explicit interfaces to other pods and a shared platform. Squads and stream-aligned teams are close relatives.

Do AI agents count as team members in a pod?

Treat agents as tools with a named human supervisor and a defined scope, not as headcount. They help with implementation and tests, but review, specification and accountability stay with people.

How big should a pod be?

About four to eight people is a common range, small enough for everyone to share context and large enough to cover the skills needed. The right size also depends on how much surface area the pod owns.

How do I know pods are working?

Dependency wait time should fall, the DORA delivery metrics should improve, and the pod's outcome metric should move. If every change still needs another team, the boundaries are wrong.