skip to content

How do you choose a branching model for a team that cannot release its shared line on demand?

level: principalimportance: should knowfreq 38%

answer

  1. Derive the model, do not adopt one
  2. Integrating is not the same as releasing
  3. Count versions alive in the field
  4. A fixed cadence often hides an approval
  5. Measure branch age, not diagram compliance

basics

~20 s

Derive the model from the obligations rather than adopting a diagram. Establish what actually blocks releasing on demand, such as approval, verification time or a contractual date, and how many versions live in the field, then choose the model paying the least divergence.

solid answer

~50 s

The choice is derived, not preferred. Three inputs decide it: how often the team can genuinely put a change in front of users, how many released versions it must support at once, and how trustworthy its automated verification is. Then separate two things that get conflated, because being unable to *release* continuously does not make a team unable to *integrate* continuously. A team on a fixed six-week cadence with a contractual delivery date can still integrate every day onto one shared line and hide unfinished behaviour at run time, cutting a separate release line only when a version must be supported after the next one starts. Long-lived parallel lines earn their cost where several versions genuinely live in the field. Whatever is chosen, measure branch age and integration failures rather than compliance with the diagram.

go deeper

for a junior

Know that no branching model is universally correct: the right one depends on how often the team can release and how many versions it has to support at the same time.

for a middle

Be ready to state what each shape demands of a team, such as fast automated verification for one shared line or an integration and stabilisation phase for long-lived parallel lines, and to name which constraint you are buying.

for a senior

Show you can find the real constraint behind a fixed cadence, whether it is approval, verification time or a contractual date, and demonstrate that integration frequency and release frequency can be decoupled in practice.

for a principal

Own the decision and its evidence: the inputs you derived it from, what you would measure to learn it was wrong, and which organisational change, such as approval or verification investment, you would trade for a shorter branch lifetime.

## The question behind the question An interviewer asking which branching model you would use is not asking for a preference. They are asking whether you can name the constraints a model has to satisfy, and whether you can tell a real obligation from an inherited habit. The answer starts by refusing the framing: you do not adopt a model, you derive one and then check whether a published shape happens to match it. ## Separate integrating from releasing The most common error is treating one cadence as both. They are different questions: - **Integration frequency** is how often a line of development rejoins the shared mainline and is verified there. It is limited by verification speed and by whether unfinished behaviour can be hidden somewhere other than a branch. - **Release frequency** is how often verified work reaches users. It is limited by approval, contract, customer appetite, regulation or a market window. A team that releases every six weeks is not thereby prevented from integrating every day. Almost always, when a team says otherwise, the underlying blocker is one of two things: it cannot hide unfinished behaviour except on a branch, or it cannot verify the shared line cheaply enough to keep it releasable. Both are solvable, and neither of them is a branching decision. ## The three inputs that actually decide 1. **The release obligation.** Not what the calendar says, but what would break if a release happened tomorrow. Approval, a stabilisation window, a customer notice period, a contractual date with money attached: each is a different constraint with a different remedy. 2. **How many versions live in the field at once.** This is the only input that genuinely forces long-lived parallel lines. If exactly one version is supported and every user is on it, parallel release lines are cost without a matching obligation. 3. **The maturity of automated verification.** Short-lived lines are safe only when the checks gating the mainline are fast and trusted. A team whose checks take hours or fail randomly will batch work regardless of what the diagram says, because people optimise around slow gates. ## A worked decision A nine-engineer car-insurance renewals team ships on a six-week cadence. One contract carries a penalty for missing a delivery date. Two versions are live in the field, because one broker integration has not migrated. The automated checks finish in under 12 minutes and the team trusts them. Derived, not chosen: - Two field versions justify **one** maintenance line for the older version, and only until that broker migrates. The migration date, not the branching model, is the thing to push on. - The six-week cadence justifies nothing at all about branch lifetime. Integration stays daily on one shared line, and unfinished renewal behaviour hides behind runtime switches. - The penalty clause argues *for* short lifetimes rather than against them, because the risk to the date is late discovery, and late discovery is precisely what long-lived lines manufacture. - The stabilisation window shrinks from eleven days to a fixed verification pass, because the shared line was already releasable every day. ## What a constraint justifies, and what it does not | Constraint | Justifies | Does not justify | |---|---|---| | Several supported versions in the field | A maintenance line per supported version, capped | A line per customer or per feature | | A regulated approval step before release | A verified point held for approval | Weeks of unintegrated work while approval runs | | A contractual delivery date | Tight scope control and early integration | Deferring integration until the date is close | | Slow or unreliable automated checks | Investment in the checks themselves | Long-lived lines as a permanent workaround | ## Measure the decision, do not defend it A model is a hypothesis about cost, so instrument it: - **Branch age at integration**, read at a high percentile rather than the median, because the median hides the lines that actually hurt. - **Integration failure rate**, and whether failures cluster near release dates. - **Time from merge to releasable**, which is the honest measure of whether the shared line is really releasable at all. - **Live switch count and age**, because the short end of the axis fails by accumulating switches instead of branches. If those numbers do not move in the direction the decision predicted, the decision was wrong, and saying so a year later is part of owning it. ## Failure modes worth naming - **Adopting a diagram** because a well-known organisation published it, without checking whether its obligations resemble yours. - **Moving to one shared line without making it releasable**, which is the fastest way to convert an integration problem into an everybody-is-blocked problem. - **A line per customer**, which turns a sales concession into an unbounded engineering commitment. - **Treating the cadence as fixed** when the real constraint is an approval step nobody has ever tried to change.

  • The team says it cannot integrate continuously because it releases only every six weeks. How do you test that claim?
    Ask what would actually break if a change merged today and shipped in six weeks. Usually the answer is that unfinished behaviour would be visible, which a runtime switch solves, or that the shared line could not be kept verifiable, which is a verification investment rather than a branching decision. If neither is true, a release constraint is being borrowed as an integration constraint.
  • When are long-lived parallel release lines genuinely the right answer?
    When several released versions are supported in the field at the same time: customers who cannot upgrade on demand, software installed on equipment, or a version a regulator requires to keep receiving fixes. There the divergence cost is not avoidable, it is the cost of the support obligation, and the real decision becomes how many versions the organisation is willing to carry at once.
  • A year after the decision, what would tell you it was wrong?
    Branch age creeping up at the high percentiles, integration failures clustering near release dates, more calendar time spent stabilising than building, or a growing pile of runtime switches nobody removes. Each of those says the model is costing more than the alternative it was chosen over, and each is a reason to revisit the decision rather than to defend it.

saying these in an interview costs you the question

  • Picks a model by reputation rather than the team's obligations
  • Confuses being unable to release often with being unable to integrate often
  • Adds a long-lived line per customer without bounding the count
  • Moves to one shared line without keeping it releasable
  • Measures compliance with a diagram instead of branch age