Every landing zone conversation eventually lands on the same fork: subscription-per-team or subscription-per-environment. Pick one, defend it in the design review, move on. I used to think that fork was the decision. It isn't. It's a proxy for a question nobody actually asks, which is whether your environments are things you *have* or things you *make*.

We hit this a few weeks back building out a branching strategy for a product that needed to ship in phases — not one big release, several overlapping ones, each needing its own slice of infrastructure to validate against before merging up the chain. The instinct in every Azure reference architecture I'd read was to stand up a fixed set of subscriptions — dev, qa, uat, prod — and let teams queue for access to the shared ones. Clean org chart. Terrible fit for what we were actually doing, which was running three or four release branches at once, each wanting its own isolated environment for a week or two and then wanting to disappear.

So, we didn't fix the environments. We templated them.

The branching strategy and the environment strategy ended up being the same decision, which surprised me at the time. Every release branch got a corresponding environment spun up from Terraform, wired into the pipeline automatically the moment the branch existed, torn down automatically once it merged or went stale. No ticket. No "can I borrow QA for the afternoon." The subscription-per-environment debate assumes environments are scarce and long-lived enough to be worth governing carefully as static things. Once provisioning is cheap and repeatable, that assumption just stops holding.

Here's the number that made the case for me, not some theoretical justification. Before this, we were running four non-prod subscriptions, always on, mostly idle outside business hours, because nobody wanted to be the one who tore down an environment someone might still need. After moving to on-demand provisioning tied to branch lifecycle, we typically had one to two environments alive at any given moment instead of four sitting there permanently. That's not a rounding error. That's roughly half the standing footprint gone, for infrastructure that was doing the same job.

I won't pretend this is free. Ephemeral environments push a lot of discipline requirements onto your IaC that a static model lets you get lazy about. If your Terraform templates aren't actually idempotent — if there's some manual step, some hand-configured firewall rule, some secret someone pasted in once and forgot to script — dynamic provisioning will find that gap for you, repeatedly, at the worst time. We found ours in a Key Vault access policy that had been set by hand eight months earlier and never made it into the template. First time a fresh environment failed a smoke test, it took an afternoon to figure out why "prod-like" environment #3 didn't behave like the original.

There's also a real counterpoint here, and it's not a strawman: audit and compliance people like fixed environments. A subscription that's existed for two years with a known history is easier to reason about for a SOC 2 review than one that spins up Tuesday and dies Friday. If your organization's compliance posture depends on long-lived resource identity — not just "the config was correct" but "this specific resource has been continuously monitored since provisioning" — ephemeral environments genuinely complicate your story. That's a real cost. I'm not going to hand-wave it away with better logging. You need to decide whether your compliance framework cares about resource continuity or just about proving the right controls were in place at time of use and design your audit trail around whichever one it actually is.

For us, it wasn't. The controls mattered, the specific subscription's birthdate didn't. So, the trade-off was worth making.

What I'd push back on is treating subscription-per-team vs subscription-per-environment as the primary architectural decision in the first place. It's a structural question about naming and boundaries. The actual lever — the one that changes your cost profile, your pipeline design, and how fast a team can validate a branch before it merges — is whether "environment" means a durable thing you provision once and then manage, or a disposable output of your pipeline that happens every time you need it. Landing zone docs spend pages on the former and barely mention the latter, probably because it's harder to draw on a slide. A static subscription topology is easy to diagram. "Environments are ephemeral outputs of the release pipeline" doesn't fit neatly into an org chart, so it gets left out of the reference architecture even when it's the more honest answer for a fast-phased release model.

If you're mid-debate on subscription topology right now, my actual advice is to shelve that question for a week and instead ask whether your team could provision a working non-prod environment from scratch, unattended, in under half an hour. If the answer is no, fix that first — the subscription boundary question becomes almost irrelevant once you can. If the answer is yes, you've probably already made the topology decision without realizing it, because ephemeral environments don't care much which subscription boundary they sit inside. They just need somewhere to land and a template that doesn't lie about what production actually looks like.

Every landing zone conversation eventually lands on the same fork: subscription-per-team or...

Subscription-per-environment was never the real question

Tummala Krishna Kishore

Most architecture decision records fail for the opposite reason people think. The issue usually isn't that teams forget to write them. It's that the ones they write are filled with the wrong content. The key information a reader needs—why this option instead of the others—often gets buried on page three under a list of API changes.

An ADR has one job: capture a decision that is costly to reverse, along with the reasoning that led to it, while that reasoning is still fresh. That's all. It isn't a design document, a specification, or a collection of research. If you keep that focus, everything else about what to include or leave out will follow naturally.

**The format that still works**
Michael Nygard's original ADR template from 2011 (title, status, context, decision, consequences) has lasted for a reason. It directly addresses the key questions a future reader has: What was the situation? What did we decide? What did we give up? Teams that add ten extra sections, like owners, review dates, risk matrices, or approval lists, usually end up with a document no one finishes reading, which defeats the purpose. If your ADR template is longer than the time it takes to fill it out for a simple decision, cut sections until it’s more concise.

A useful rule of thumb is that an ADR longer than a page and a half is often a design document masquerading as an ADR. This isn’t a strict rule, but I haven’t seen a truly good ADR exceed 600 words. The decisions worth documenting this way can be stated, justified, and owned in about a page. If that's not possible, the record isn’t the issue. The decision is probably still tied up with other unresolved matters.

**What belongs**
The decision, stated clearly. "We will use event-driven integration between the order and inventory services instead of synchronous REST calls" is a decision. "The order service integrates with inventory" simply describes the current state and belongs in a wiki, not an ADR.

The challenges faced. Describe the two or three actual constraints that were in conflict, not a comprehensive literature review. For example, a latency budget versus consistency guarantees, team ownership boundaries versus a shared database that made those ownership lines unclear, or cost limits versus the vendor lock-in that comes with a cheaper option. If there was no real conflict, you probably didn't need an ADR.

The alternatives you seriously considered, along with why they weren’t chosen. Focus on the options a competent engineer would likely ask about six months later. For example, "We looked at a shared database with row-level locking; we rejected it because it recreated the coupling we wanted to eliminate between the two teams' deployment cycles." This simple statement saves the next person from rehashing a decision that's already been made.

The consequences, including the ones you’re not thrilled about. This is often the section teams skip, but it offers the highest value. Every genuine architectural decision comes with costs. If you adopt event-driven integration, you trade the simplicity of synchronous actions for eventual consistency and a tougher debugging process when a message is lost. Document that. An ADR that lists only the benefits isn't a valid record of a decision. It's a sales pitch to your future self, and future-you won’t be fooled more than once.

**What doesn’t belong**
Implementation details. Class names, endpoint paths, table schemas, retry counts—these change frequently and can quickly make the document outdated. If the ADR needs a code example to clarify its point, it likely indicates that the decision being documented is more about implementation than architecture, and it should belong in the code or design document instead.

Decisions that are not settled yet. If three options are still in play and no one has chosen one, that's a design document or a spike ticket. Writing an ADR for a decision still in progress creates a record that contradicts itself by the time it gets approved. Contradictory records are worse than having no records; they mislead the following reader.

A decision made after the fact to meet process requirements. This rubber-stamp scenario is more common than teams want to admit. Someone builds the solution and then creates the ADR retroactively because it's required by the checklist. The "alternatives considered" section becomes fictional, as nothing was actually considered. The option that got released is the only one that ever existed on paper. Readers can tell the difference. An ADR written after the code is merged feels different from one written beforehand. Once a team’s ADRs acquire a reputation for being just for show, people stop reading them, which is worse than never having them required.

Every decision, regardless of its importance. This is the trade-off people often avoid stating clearly: requiring an ADR for every non-trivial pull request leads to a pile of records. For example, both the choice to follow field-naming conventions and the decision to go fully async receive the same template and attention. The signal-to-noise ratio diminishes, and the truly important records—those concerning team boundaries, data ownership, or long-term platform choices—get lost among many similar entries about logging formats. Save ADRs for decisions that are genuinely challenging to reverse: those that affect team boundaries, data ownership, or a platform choice you'll live with for years. Smaller considerations can go in a pull request description or a design note.

**The crucial test**
Before you write the next one, ask yourself: if this decision turns out to be wrong in eighteen months, would the person troubleshooting it appreciate this document? If the answer is that they would skim through the generic content looking for the paragraph explaining why the obvious choice wasn’t made, write that paragraph first and build the rest of the record around it. Everything else, like the status field, review date, and approval chain, is optional. The reasoning is the key part; treat it that way, and the format will fall into place.

Most architecture decision records fail for the opposite reason people think. The issue usually isn't...