GOTO Conferences · Published 2026-08-19

Modern Enterprise Architecture: Architecting for Outcomes • Simon Rohrer • GOTO 2025

privateReview: unreviewedConfidence: high
enterprise architecturedevopsagilegovernanceevolutionary architectureenterprise-architectureconways-lawhandoffscouplingcontinuous-governanceplatform-engineeringevolutionary-architecturevalue-streams
Open on YouTube ↗

Summary

Overview

  • Speaker: Simon Rohrer
  • Channel: GOTO Conferences
  • Main topic: Modern Enterprise Architecture and aligning people, value, and technology
  • Purpose: To redefine enterprise architecture for modern software engineering organizations, providing patterns for sustainable flow, alignment, and governance. Simon Rohrer presents a modern approach to enterprise architecture, reframing it away from traditional phase-based, siloed, and bureaucratic practices toward a continuous, conversational, outcomes-oriented discipline inspired by Agile, DevOps, and Conway's Law.

Topic Map

Introduction and Journey

  • Explanation: Simon introduces his background as a developer, enterprise architect, and transformation lead, setting the stage for why modern enterprise architecture requires a paradigm shift.
  • Key claims:
    • Enterprise architecture as traditionally practiced is broken.
    • Modern enterprise architecture is about outcomes.
  • Examples:
    • Experience at Saxo Bank
  • Terminology:
    • Enterprise Architecture
    • Ways of Working
  • Why it matters: Establishes credibility and context for the talk.

The ABCD Framework of Modern Enterprise Architecture

  • Explanation: A breakdown of five core pillars: A (Aligning Value, People & Technology), B (Better Value, Sooner, Safer, Happier), C (Continuous & Conversational Governance), D (DevOps at Enterprise Scale), and E (Evolutionary Enterprise Architecture).
  • Key claims:
    • Architecture must align business, organization, and technology.
    • Complexity is the enemy, and enterprise architecture is the solution.
  • Examples:
    • Conway's Law feedback loops
  • Terminology:
    • Conway's Law
    • DevOps
    • Evolutionary Architecture
  • Why it matters: Provides a structural mental model for the audience.

Key Points

Complexity is the Enemy

  • Explanation: Unmanaged systems grow into spiders' webs of high coupling and high coordination costs.
  • Evidence: Quotes Roger Sessions and David Woods.
  • Practical implication: Architects must govern realized architectures and reduce handoffs.

Conway's Law Feedback Loop

  • Explanation: Organization architecture drives system architecture, and system architecture constrains organization architecture.
  • Evidence: Ruth Malan and Allan Kelly quotes.
  • Practical implication: Design organization and system architecture together.

Frameworks, Models & Processes

The MEA ABCDE Framework

  • How it works: Aligns value, people, and technology around outcomes and continuous governance.
  • Components:
    • Aligning Value, People & Technology
    • Better Value Sooner Safer Happier
    • Continuous & Conversational Governance
    • DevOps at Enterprise Scale
    • Evolutionary Enterprise Architecture
  • When to use: When scaling software development across modern enterprise organizations.

Examples & Case Studies

Transitioning from siloed project delivery to product-aligned teams at Saxo Bank.

  • Illustrates: Moving from project mindset to product mindset.
  • Lesson: Reduce coordination costs and handoffs.

Actionable Takeaways

  • Immediate:
    • Stop doing phase-gated architecture reviews on paper.
    • Align teams around value streams.
  • Strategic:
    • Adopt evolutionary architecture principles.
    • Implement platform engineering for automated governance.
  • Questions to investigate:
    • How many handoffs exist in your delivery pipeline?
    • Is your architecture team collaborating continuously with operations and delivery?

Claims Worth Verifying

  • Removing one dependency removes handoffs from 4 to 1, improving efficiency 4x and reducing risk 8x. (statistic)

Notable Quotes

"Enterprise architecture doesn't exist." "Complexity is the enemy. Enterprise architecture is the solution. The only solution."

Compressed Summary

  • Move from project to product thinking
  • Embrace continuous conversational governance
  • Avoid architecture review boards that rubber-stamp paper designs
  • Leverage platform engineering for automated compliance
  • Keywords: enterprise architecture, devops, agile, governance, evolutionary architecture
  • Core insight: Modern enterprise architecture must be continuous, conversational, and aligned with value streams rather than bureaucratic and phase-gated.

Core insights

5
Mental Modelmedium noveltystrong evidence

Conway's Law is a feedback loop, not a one-way observation: organization architecture drives system architecture, and once embedded, the system architecture constrains future organization options. That makes organization design an architecture tool.

Why it matters

For agentic and multi-agent systems, the team chart doubles as the dependency graph of agents/tools; assigning ownership without considering runtime boundaries will create coupling that is hard to reverse.

Generalization

When decomposing an AI product into agents, pipeline stages, and supporting infrastructure, treat the org chart as a candidate architecture diagram and co-design both recursively.

Organization architecture drives system architecture, and system architecture constrains organization architecture.
Open source video
Design organization and system architecture together.
Open source video
Mechanismhigh noveltyweak evidence

Performance and reliability are dominated by dependency topology, not just by local step speed: removing one dependency collapses a four-step handoff chain into one handoff and is claimed to improve efficiency by 4x and reduce risk by 8x.

Why it matters

The highest-leverage intervention in a delivery or agent pipeline is identifying and removing coupling points rather than optimizing individual agent/tool latencies.

Generalization

Instrument multi-agent request graphs by number of serial dependencies/handoffs; a single architectural de-coupling can outperform many local performance optimizations.

Removing one dependency removes handoffs from 4 to 1, improving efficiency 4x and reducing risk 8x.
Open source video
Practicemedium noveltystrong evidence

Governance should be continuous and conversational, not delivered as phase-gated paper reviews. Architecture must be evaluated against the realized system, not against the intended design documents.

Why it matters

For AI safety, compliance, and runtime quality, one-time human sign-off of a design is structurally weaker than continuous checks against actual behavior.

Generalization

Production agent systems need deployment-time and runtime guardrails—policy as code, live evaluation, and platform-embedded checks—rather than pre-implementation architecture review rituals.

Stop doing phase-gated architecture reviews on paper.
Open source video
Continuous & Conversational Governance
Open source video
Architecturemedium noveltymoderate evidence

Platform engineering is the enabling mechanism for automated governance and evolutionary architecture: shared infrastructure absorbs cross-cutting concern and lets teams remain aligned to value streams without drifting into a spider web.

Why it matters

Architectural guardrails/compliance checks must live in the internal platform—encoded, versioned, and enforced—if product-aligned teams are to move independently at enterprise scale.

Generalization

In AI engineering, common policy, safety, and observability capabilities should be built as an internal platform product and reused by every agent/team, rather than re-created per project.

Implement platform engineering for automated governance.
Open source video
Leverage platform engineering for automated compliance.
Open source video
Architecturemedium noveltymoderate evidence

Value-stream alignment is boundary design: organizing people around outcomes and products instead of temporary projects reduces coordination costs and handoffs, which is equivalent to reducing unnecessary coupling between the parts of the system those people run.

Why it matters

The ownership structure of an agent platform determines the number of cross-team API agreements, context-transfers, and waits; durable product ownership creates stable, bounded architectural surfaces.

Generalization

For an agentic system, assign agent components to long-lived outcome-oriented teams, and treat the platform team as the mechanism for handling shared concerns without introducing project-shaped dependencies.

Align teams around value streams.
Open source video
Reduce coordination costs and handoffs.
Open source video

Deep dives

4

Handoff reduction multipliers in multi-agent pipelines

Research question

How should handoffs be counted across modern delivery and agent pipelines, and does removing a single serial dependency replicate the claimed 'efficiency 4x and risk 8x' improvements?

Why

The handoff claim in pass 1 is unverified and has outsized consequences: if dependency removal dominates local optimization, AI teams should spend architecture effort on topological cuts instead of latency tuning.

Removing one dependency removes handoffs from 4 to 1, improving efficiency 4x and reducing risk 8x.
Open source video
Source video

Runtime-first architecture governance

Research question

What mechanisms and metrics can continuously compare a realized system's behavior to architectural intent, replacing phase-gated paper reviews?

Why

Pass 1 contrasts one-time paper sign-offs with continuous and conversational governance; with autonomous agents, the only trustworthy enforcement loop is runtime and deployment-time policy.

Stop doing phase-gated architecture reviews on paper.
Open source video
Continuous & Conversational Governance
Open source video
Source video

Conway's Law feedback loop in agent-team co-design

Research question

When agent/tool ownership is changed along with the runtime request graph, how does the Conway feedback loop affect coupling decay and recovery?

Why

Conway's Law is presented as a two-way feedback loop, making organization design an architecture instrument. Agent ecosystems intensify this because org boundaries are also API boundaries.

Organization architecture drives system architecture, and system architecture constrains organization architecture.
Open source video
Design organization and system architecture together.
Open source video
Source video

Avoiding the central-platform bottleneck in automated governance

Research question

What internal-product patterns allow a platform engineering team to encode automated governance without becoming a high-coordination coupling point itself?

Why

Pass 1 says platform engineering is the enabling mechanism for automated governance, but also flags that a central platform can become the spider web it was meant to prevent.

Implement platform engineering for automated governance.
Open source video
Leverage platform engineering for automated compliance.
Open source video
Source video

Article ideas

4

The Handoff Is the Metric Your Architecture Review Never Tracks

The best architectural intervention is removing serial handoffs—between teams, tools, and agents—because it compounds latency and risk reduction where local optimization gives only linear gains.

Angle

Treat handoff count as an operational metric and automate its measurement across CI/CD and agent traces.

Source video

Stop Reviewing Paper Architectures; Govern the Realized System

Phase-gated document reviews create a false sense of control; architecture governance should be encoded into platform/runtime checks that continuously validate what is actually running.

Angle

Make the contrast between a one-time human architecture approval and a policy-checked release pipeline.

Source video

Your Organization Chart Is Also Your Agent Dependency Graph

The same cut lines that create team boundaries will become runtime coupling between agents and services, so org design should be treated as a software architecture decision and vice versa.

Angle

Apply Conway's Law to agent platform ownership, including which one team should own the shared agent or toolkit.

Source video

Platform Teams: The Cure That Can Become the Coupling

Automated enterprise-scale governance requires a platform layer, but unless it is run as an internal product with stable APIs and bounded responsibilities, it will become a new handoff bottleneck.

Angle

Show how the same spider-web dynamics that affect value-stream teams can appear inside the central platform.

Source video

Project ideas

3

Handoff cut experiment harness

movement-lab

Reducing serial handoffs in an end-to-end multi-agent workflow by one yields disproportional gains in latency, success rate, and cost.

Proof of concept

Stand up a 4-step pipeline (e.g., ingest -> classify -> orchestrate -> output), instrument each hop with a trace ID, then remove the orchestrator hop and compare.

Measurement

P95 end-to-end latency, success rate, number of serial handoffs, operational cost per run.

Source video

Live architecture guardrail

gatehouse

Runtime policy checks (policy-as-code on the request/event path) detect architectural drift significantly faster and with less human effort than phase-gated document approval.

Proof of concept

Create a mutable agent/service sandbox with architecture rules (e.g., no bypassing auth gateway, every agent must use a tracing library); introduce a rule-violating change and measure detection time using an alerting policy engine.

Measurement

Detection latency (minutes vs review cycles), false positives, reviewer hours consumed.

Source video

Conway mirror

new

Cross-boundary edges in the runtime agent dependency graph that are not backed by a corresponding team/API ownership boundary will show higher failure and rework rates than contained edges.

Proof of concept

Import a sample team-to-service/agent ownership map and a distributed trace graph; flag graph edges crossing team ownership without an explicit platform interface; correlate with recent incident and cycle-time data.

Measurement

Cross-boundary edge count, failure rate, mean time to repair for boundary-crossing edges vs internal edges.

Source video

Architectural implications

5

The org chart and the system dependency graph mirror each other; they should be changed together.

Before

Architecture teams publish target diagrams and judge paper designs without changing the org.

After

Architectural decisions are evaluated against both the live dependency graph and the team ownership graph.

Consequence

When introducing agents or services, run small boundary experiments by rewiring ownership and observing handoff/error changes before committing to a topology.

Source video

Handoffs are a leading indicator of architectural quality.

Before

Teams optimize for per-step latency and throughput metrics.

After

Teams also measure number, length, and cost of handoffs between people, services, and agents.

Consequence

Add handoff/dependency tracing to CI/CD and runtime instrumentation so queue, context-loss, and coordination paths become visible.

Source video

Paper-based design approval is not governance of the realized system.

Before

An architecture review board approves designs at a fixed project milestone.

After

Platform and runtime checks continuously compare actual behavior to intended architectural constraints.

Consequence

For AI system safety, put policy checks in the request path and release pipeline so violations are blocked as they occur, not at a review meeting.

Source video

Evolutionary architecture requires governance to be mechanically encoded.

Before

Architecture is conceived as a fixed future target that everyone commits to.

After

Platform regulations and conventions are treated as code that can evolve safely alongside the system.

Consequence

Architecture becomes a set of mutation-tolerant guardrails rather than a frozen blueprint; this is a safer model for fast-moving agentic systems.

Source video

Project-based delivery creates temporary central coordination points.

Before

Specialists from different departments join a cross-functional project, then disband.

After

Durable product-aligned teams own a stream of work from development through operations.

Consequence

Product-centric ownership should reduce handoffs, but platform teams are still required to prevent divergent duplicate infrastructure from being built independently by each product team.

Source video

Tradeoffs and failure modes

3

Continuous conversational governance

Benefit

Architecture is continuously checked against the realized system, catching drift before it hardens.

Cost or risk

If it relies only on human conversations rather than automated platform enforcement, architecture becomes another queue and another series of handoffs.

Continuous & Conversational Governance
Open source video
Source video

Product/value-stream alignment

Benefit

Fewer cross-team handoffs and seconded-team bottlenecks.

Cost or risk

Decentralized product teams may re-implement shared concerns unless a platform organization supplies common infrastructure and conventions.

Align teams around value streams.
Open source video
Source video

Dependency removal

Benefit

A single dependency reduction can produce outsized efficiency and risk gains.

Cost or risk

Careless dependency removal may discard a legitimate control point, standardization boundary, or essential telemetry vantage point.

Removing one dependency removes handoffs from 4 to 1, improving efficiency 4x and reducing risk 8x.
Open source video
Source video

Open questions

4

How many handoffs exist in your delivery pipeline?

Why unresolved

The talk makes handoffs central, but does not present a standard instrument or method for counting them across people, tools, and agents.

Research direction

Build a dependency/handoff map of an end-to-end delivery or agent workflow and correlate handoff count with cycle time and defect rate.

Source video

Is your architecture team collaborating continuously with operations and delivery?

Why unresolved

Continuous architecture governance requires a channel between architecture intent and what actually runs; the talk does not describe the concrete cadence or tooling.

Research direction

Prototype an event-stream architecture review where changes to deployed systems trigger architectural feedback instead of waiting for milestones.

Source video

Can removing one dependency really produce 4x efficiency and 8x risk reduction?

Why unresolved

The summary categorizes the statistic under 'Claims Worth Verifying,' so it is asserted but not supported by data in the included materials.

Research direction

Run a controlled A/B experiment that removes one central dependency from a real multi-agent pipeline and measures throughput, error rate, and cost.

Source video

How do you build a platform layer that automates governance without becoming a new coupling bottleneck?

Why unresolved

Platform engineering is presented as the answer to decentralization, yet any central platform itself can become the kind of high-coordination dependency the whole talk opposes.

Research direction

Treat the platform as an internal product with APIs, service-level objectives, and a roadmap, and measure whether its consumers still own end-to-end outcomes.

Source video

Key claims

6
causalVerification needed

Removing one dependency removes handoffs from 4 to 1, improving efficiency 4x and reducing risk 8x.

Evidence

Removing one dependency removes handoffs from 4 to 1, improving efficiency 4x and reducing risk 8x.

Question

Which dependency in which pipeline was removed, and how were efficiency and risk measured?

Source video
causalVerification needed

Organization architecture drives system architecture, and system architecture constrains organization architecture.

Evidence

Organization architecture drives system architecture, and system architecture constrains organization architecture.

Question

What empirical evidence demonstrates both directions of this feedback loop in large software organizations?

Source video
causalVerification needed

Unmanaged systems grow into spiders' webs of high coupling and high coordination costs.

Evidence

Unmanaged systems grow into spiders' webs of high coupling and high coordination costs.

Question

How should coupling and coordination cost be measured over time to validate this claim?

Source video
opinionVerification not requested

Architecture must align business, organization, and technology.

Evidence

Architecture must align business, organization, and technology.

Source video
causalVerification needed

Project-to-product alignment reduces coordination costs and handoffs.

Evidence

Reduce coordination costs and handoffs.

Question

What case-study evidence controls for other organizational changes during a project-to-product transition?

Source video
opinionVerification not requested

Phase-gated architecture reviews on paper should be stopped.

Evidence

Stop doing phase-gated architecture reviews on paper.

Source video

Connections

5