skip to content

EA Governance

How architectural decisions get reviewed and enforced: review boards, waivers and exceptions, compliance scoring, and gates tied into the SDLC and portfolio process. The tension worth discussing is enforcing standards without becoming the team that blocks delivery.

part ofSoftware design & architectureoverview, primer and where to startread it →
on this pageshow

questions

5

What is an Architecture Review Board (ARB), and what decision does it typically make when a project reaches an architecture review gate?

level: juniorimportance: must knowfreq 70%

answer

  1. ARB = checkpoint not designer
  2. tiered review by risk
  3. gate tied to PPM funding release
  4. governance theater vs bottleneck
  5. exception log feeds principle revision

basics

~10 s

A group of senior architects that checks a project's design against company rules before it can move forward, and either approves it, asks for changes, or grants an exception.

solid answer

~40 s

The ARB is a standing committee (chief architect, domain/solution architects, sometimes security/infra leads) that reviews a project's proposed architecture at defined checkpoints - typically before major funding release or before moving from design to build. It checks the design against enterprise principles, reference architectures, and standards, and produces one of three outcomes: approve, approve-with-conditions, or reject/waiver-required. It's a control point, not a design authority - the board doesn't design the solution, it validates alignment and flags risk (duplicated capability, unsupported tech, security gaps) before money is spent building it. Its authority comes from being tied to a PPM/SDLC gate - no ARB sign-off, no funding release or stage transition.

go deeper

for a junior

Should know the ARB exists as a checkpoint and that it produces approve/reject/waiver outcomes tied to a gate; doesn't need to design the tiering model.

for a middle

Should be able to describe what artifacts get submitted, roughly when in the SDLC review happens, and why it's tied to a funding gate.

for a senior

Should be able to design or critique a tiering scheme (which changes get full review vs lightweight), and explain how to keep the board fast without losing rigor.

for a principal

Should be able to diagnose governance-theater vs bottleneck failure modes portfolio-wide from indicators like approval rate and cycle time, and redesign the operating model, e.g. by revising stale principles based on exception patterns.

## What the board is An **Architecture Review Board (ARB)** is a standing governance body - usually the chief/enterprise architect plus a rotating set of domain architects, security, infrastructure, and sometimes a business sponsor - whose job is to check a proposed solution design against the organization's **architecture principles**, **reference architectures**, and **technology standards** before the project is allowed to proceed to the next stage of delivery. ## How a review runs Mechanically, the process works like a **checkpoint gate**. A project team submits an architecture artifact (a solution design document, a set of ADRs, a target-state diagram) at a defined point in the SDLC - commonly at the end of a design/discovery phase and again before major implementation funding is released. The board reviews it against a checklist derived from the EA principles, e.g., 'buy before build', 'no new integration middleware without approval', 'data must live in the system of record'. It then issues one of three outcomes: 1. **Unconditional approval.** 2. **Conditional approval** - approved provided named conditions are met, often re-checked at a later gate. 3. A required **exception/waiver** if the design cannot or will not comply. ## Why it exists The reason this exists is that architecture decisions made independently by dozens of delivery teams, each locally rational, tend to be globally expensive: - duplicated integration patterns - incompatible data models - redundant tooling licenses - security gaps that only become visible when systems are composed together A single team optimizing for its own deadline has no incentive to check whether another team already solved the same problem, or whether its chosen database violates a data-residency commitment made at the enterprise level. The ARB is the mechanism that inserts an enterprise-level check into what would otherwise be a purely local decision, and it derives its **teeth** from being wired into a funding or stage gate in **project portfolio management (PPM)** - a project literally cannot draw down its next tranche of budget, or move from 'design' to 'build' in the SDLC, without a recorded ARB outcome. Without that binding to a gate, an ARB becomes advisory only, and advisory boards are the first thing project managers route around under deadline pressure. ## The trade-off The central trade-off is **speed versus enterprise-wide coherence**. Every review adds latency and a scheduling dependency - if the ARB only meets biweekly, a project can lose two weeks waiting for a slot, and if the board is broad and generalist it may lack the specific technical depth to give a fast, confident answer, so it defaults to caution and asks for more documentation, adding more delay. Organizations manage this by **tiering** review: - low-risk, low-cost, already-pattern-conformant changes get a lightweight self-attestation or automated check - only high-risk, high-cost, or novel-technology projects get a full board review Get the tiering wrong and you either bottleneck the whole portfolio or the ARB becomes a rubber stamp because it's forced to approve on a compressed timeline without real scrutiny. ## Failure modes Failure modes show up in a few recognizable patterns. - **The first is 'governance theater'**: the board exists, meets, and approves nearly everything because it has no real authority to block funding, so project teams treat the review as a formality to check off rather than a genuine design conversation - visible in audit as a near-100% approval rate with almost no conditions attached. - **The second is the opposite failure, 'bottleneck governance'**: the board becomes the long pole in every schedule because it's understaffed relative to portfolio volume, review criteria are vague so every session runs long, and teams start scheduling architecture review as if it were a construction permit. - **The third is 'stale principles'**: the board keeps enforcing standards that predate a since-adopted technology, which erodes the board's credibility and drives shadow IT, where teams build outside the ARB's visibility entirely to avoid the friction. ## A worked example A concrete example: a bank might run an ARB gate at the end of the 'solution design' phase for any project above a cost or risk threshold, requiring sign-off before the PMO releases build-phase funding; the board checks the design against a small set of non-negotiable principles using a standard checklist, and any deviation is logged as a formal exception with an **expiry date** and an **owner**, rather than silently waived. That exception log itself becomes an input to the next governance cycle - a principle that accumulates many exceptions is a signal it's either wrong or unenforceable as written, and a healthy governance process revisits and revises it rather than treating every waiver as a one-off failure of discipline.

  • What happens if a project team simply ignores the ARB and ships anyway?
    In a well-run governance model this isn't structurally possible because the ARB outcome is a hard input to a PPM or SDLC gate - no recorded sign-off means no funding release, no environment promotion, or no production deployment approval. If it IS possible to ship without the sign-off, that's evidence the governance process has no real enforcement mechanism and is advisory only, which usually means it will be routinely bypassed under deadline pressure.
  • How do you keep the ARB from becoming a bottleneck as the number of projects grows?
    Tier the review by risk and cost so only genuinely novel or high-impact changes get a full board session, push low-risk conformant changes through lightweight self-attestation or automated fitness-function checks, and staff the board with enough rotating domain architects that review capacity scales with portfolio volume rather than being fixed.
  • Who typically sits on an ARB and does that composition matter?
    Usually a chief or lead enterprise architect chairs it, with domain/solution architects, security, and infrastructure representation, sometimes a business sponsor for major initiatives. Composition matters because a board without the right domain depth either rubber-stamps decisions it can't evaluate or stalls asking for more documentation it doesn't know how to interpret.

Like a building permit review board: it doesn't design your house, but it checks your blueprint against zoning and safety code before you're allowed to break ground, and a variance request is how you legally deviate from the code.

saying these in an interview costs you the question

  • describes the ARB as designing the solution rather than validating it
  • can't explain what happens on rejection (no waiver/escalation path)
  • assumes ARB review has no connection to funding or SDLC stage gates
  • treats every review as identical weight regardless of risk/cost
  • no mention of who has authority to approve vs who merely advises

context

open as a page

A project team can't meet a mandatory architecture principle before its go-live deadline. Walk through how an exception/waiver process should handle this so the deviation doesn't just get lost.

level: middleimportance: must knowfreq 65%

basics

~10 s

The team formally asks for permission to break the rule, explains the risk, gets a time limit and an owner assigned to fix it later, and the request is tracked so it isn't forgotten.

open as a page

How should EA governance checkpoints be placed across the SDLC and tied into project portfolio management (PPM) funding gates, and what goes wrong when the gate is placed too early or too late?

level: seniorimportance: must knowfreq 55%

basics

~20 s

Architecture checks should happen at key funding/decision points in a project's lifecycle - early enough to catch problems before money is spent building the wrong thing, but late enough that there's an actual design to review.

open as a page

How is architecture compliance scoring typically constructed for a project or a portfolio, and what makes a compliance score misleading if it's built poorly?

level: seniorimportance: should knowfreq 45%

basics

~20 s

It's a percentage showing how well a project follows the architecture rules, based on how many principles it meets versus breaks - but it can lie if it treats a minor rule and a critical security rule as equally important.

open as a page

At the scale of hundreds of concurrent projects, how would you design principle enforcement so it doesn't collapse into either governance theater or an unstaffable bottleneck?

level: principalimportance: should knowfreq 35%

basics

~10 s

Automate the easy, objective rule checks so they run constantly without needing people, save human review time for the genuinely hard judgment calls, and keep revisiting the rules themselves so they don't go stale.

open as a page