Marry the map and the sprint a live gaming platform shows how.
A lot of people confuse ADM and Agile.
Sometimes TOGAF practitioners ignore Agile as if a good architecture slide deck ships itself. Sometimes Agile warriors ignore TOGAF as if sprints alone will sort out migration, data ownership, and enterprise governance.
Both camps lose.
If you marry both you get something better standard, beautiful results not perfect, but repeatable. Architecture that names what to change and in what order. Delivery that proves each slice before the next. On a live gaming platform, that marriage is not academic. Players, money, and latency do not wait for your methodology debate.
This article is ADM and Agile not vs. How they complemented each other when we moved from a monolith toward modular game engines, matchmaking and WebSockets, brokers, real-time query, and scale using the Architecture Development Method for the spine and Agile for the heartbeat.
Two words people treat as enemies.
| ADM (TOGAF) | Agile | |
|---|---|---|
| Answers | Why change? Capabilities? Migration? Govern? | What ships this sprint? Inspect and adapt? |
| Rhythm | Iterative architecture cycle (phases A–H) | Iterative delivery (backlog → sprint → retro) |
| Risk when alone | Beautiful target state, nothing in production | Fast features, duplicate buses, no migration map |
| Together | ADM sets boundaries and sequence; Agile lands increments | |
One line:ADM is the map and the sequence. Agile is the engine. Gaming needs both.
Why a gaming platform is a honest test.
High-scale gaming and payments punish half-methods:
Hot paths — live tables, matchmaking, wallets — cannot wait for a yearly architecture review
Many squads— lobby, game, transactions, platform — need a shared map or they invent private truths
Migration is real— monolith → modules → brokers → analytics — not a greenfield fantasy
Change never stops— new abuse patterns, new playlists, new scale events
If ADM only works on calm HR portals, it is not Enterprise Architecture. If Agile only works on a single greenfield app, it is not enterprise delivery. A live game platform is where the marriage shows its value.
| ADM phase | Agile practice | Gaming example |
|---|---|---|
| Preliminary | Working agreements, ADRs, DoR | Money off hot path; one writer per table; door vs room |
| Phase A — Vision | Epic, product goal | Modular monolith — lobby, game, transactions independent |
| Phases B–D | Spikes, sprint zero | REST matchmaking → WebSocket play; RabbitMQ off money path |
| Phase E | PI planning, prioritized backlog | Kafka when analytics needs history; Spark build vs EMR buy |
| Phase F — Migration | Incremental release, flags | Strangler off monolith — transactions module first |
| Phase G — Governance | Retro, ADRs, ARB | Hazelcast + Redis CAP choice recorded once |
| Phase H — Change | Continuous improvement | Fraud, RTQE consumers, fleet scale — cycle repeats |
Preliminary + team working agreements
ADM:principles, scope, who owns architecture decisions.
Agile: Definition of Ready, squad charters, architecture decision records in the backlog.
Gaming example: principles we actually enforced — money off the gameplay hot path; one writer per live table; matchmaking as door, WebSocket as room; reuse enterprise events before shadow copies.
Without this marriage, every squad optimizes locally. RabbitMQ in one place, Kafka in another, REST polls for the game loop and nobody owns the seam.
Phase A (Vision) + epics
ADM:business drivers, stakeholders, target state in plain language.
Agile: product goal, epic, measurable outcomes per quarter.
Gaming example:Modular monolith so lobby, game, and transactions scale and fail independently without losing live play.” Not “microservices because Netflix.”
Phases B–D (Business, IS, Technology) + spikes and sprint zero
ADM: capabilities, application boundaries, technology standards.
Agile: architecture spikes, thin vertical slices, “sprint 0” for risky unknowns.
Gaming examples:
Business: separate gameplay from transactions capability — buy-in cannot block the tick
Applications:REST matchmaking → assign table → WebSocket for live session.
Technology:RabbitMQ for work routing on the hot path Kafka later for history and analytics ADM chose when Agile shipped which module first.
Phase E (Opportunities) + PI / roadmap
ADM: work packages, dependencies, build vs buy vs reuse.
Agile: prioritized backlog, capacity, dependency ordering across squads.
Gaming example: offline Spark segmentation ADM framed build vs EMR buy Agile time-boxed the 10-day build proof. Architecture named the tradeoff Agile proved the increment.
Phase F (Migration) + incremental release
ADM: transition architecture, coexistence, decommission rules.
Agile: feature flags, dark launch, strangler slices, no big-bang fantasy.
Gaming example: monolith → modular monolith module by moduletransactions off the game process first, then lobby paths, then scale events. Players still at tables while the map moves underneath.
Phase G (Governance) + retro + ADRs
ADM: compliance with principles, architecture board, change control.
Agile: sprint retro, backlog refinement, lightweight Architecture Decision Records.
Gaming example:Why Hazelcast for coordination and Redisfor leaderboards?logged once CAP tradeoff named so the next squad does not reopen the same fight.
Phase H (Change management) + continuous delivery
ADM: the cycle starts again when the business changes.
Agile:continuous improvement, operational learning.
Gaming example: fraud patterns, new real-time query consumers, region/zone fleet math new ADM iteration, new Agile quarters — same marriage.
What the marriage fixed (and vs)
| Without the marriage | With ADM + Agile married |
|---|---|
| TOGAF-only: 18-month target PDF; production still on monolith | ADM names split gameplay vs money; Agile ships transaction handoff first |
| Agile-only: six microservices, three buses, no decommission plan | REST matchmaking + WebSocket room in sequenced increments |
| Big-bang cutover weekend; players feel the pain | Strangler migration; live tables while map moves underneath |
| Same architecture fight every squad, every year | ADRs + principles — CAP, brokers, build vs buy — recorded once |
Without marriage — TOGAF-only smell.
18-month target architecture PDF production still on the monolith squads ignore it.
Without marriage Agile-only smell.
Six microservices in six sprints three message buses no decommission plan matchmaking polls REST for the game loop.
With marriage:
ADM says split gameplay and money and sequence the brokers. Agile ships transaction handoff via RabbitMQ in sprint N, matchmaking REST + WebSocketin sprint N+1, Kafka for BI when the business case is proveneach increment demonstrable at a live table.
Anti-patterns we said no to.
ADM once a year, Agile ignores it — architecture becomes wallpaper
Every sprint reinvents architecture — no standards, no reuse
Phase F on a slide, cutover on a panic weekend — players feel it
We’re Agile, we don’t need stakeholders — Risk, Payments, and Support still exist on gaming platforms
We’re TOGAF, we don’t need sprints — latency and competitors do not wait
Wrapping-Up
A lot of people confuse ADM and Agile Some TOGAF practitioners ignore Agile. Some Agile warriors ignore TOGAF.
Marry both.
ADM — what to change, who cares, how to migrate, what to govern iteratively
Agile — what ships this sprint, how we learn, how we improve — iteratively
On a ive gaming platform, that marriage produced standard, beautiful results — not slide-deck perfection, but map plus motion modular engines, doors and rooms for clients, brokers where they fit, real-time paths that scale, decisions recorded so the next squad does not burn the same fuel.
ADM is not the enemy of Agile. Agile is not the enemy of ADM. Confusion is the enemy. Marriage is the practice.