Architecture and cloud

Executive summary

Stage 3 is where feasible AI (Stage 2) becomes deployable enterprise architecture. You answer: Where does the solution sit in business, application, data, integration, security, and technology views? How is it built, tested, and released? Which landing zone, identity model, and network path host inference and orchestration? How does it integrate with ERP, CRM, core banking, and ITSM without duplicate writes or silent failures? Completing this stage means you can produce target-state architecture, non-functional requirements, integration contracts, and platform fit notes—not a demo VPC sketched before data readiness exists.

Outcome

Primary outcome: You can design an enterprise-grade AI solution that survives security review, integration reality, and production operations—not only a pilot container diagram.

Secondary outcomes:

• Produce Stage 3 core deliverables: capability map, target-state views, HLD with ADRs, API/test/CI strategy, landing-zone fit, integration map with failure modes.
• Separate platform engineering from product engineering decisions—who owns the runway vs who owns the aircraft.
• Explain non-functionals (latency, availability, residency, DR, cost) in language executives and enterprise architects accept.

Stage 3 does not require full production cutover. It requires you to know what would fail in architecture review before build accelerates.

Who Stage 3 is for

Profile	Typical gap	Stage 3 fix
Strong Stage 2, weak EA	Good eval plan; no target-state or ADRs	Topic 08
Developer, weak cloud	Works locally; no landing zone or IAM model	Topic 16
Architect, weak integration	Happy-path API calls; no idempotency or SoR	Topic 24
ML engineer, weak delivery	Model metrics strong; no CI for prompts/RAG	Topic 15
Consultant jumping to Stage 4	Security checklist before HLD exists	Complete 08, 15, 16, 24 first

Entry criteria

Start Stage 3 when all of the following are true:

• Stage 2 exit criteria met—or documented sponsor risk acceptance on data/eval gaps (logged, rare).
• Prioritised use case has readiness score ≥3.0 on critical sources—or explicit remediation plan with dates before customer-facing scope.
• Evaluation plan with thresholds exists (topic 21)—architecture must not substitute for eval gates.
• You can name systems of record for data the AI reads or writes.

Do not start Stage 3 when:

• Discovery produced only a chatbot wireframe with no integration inventory.
• Cloud account is a single shared sandbox with no identity separation.
• "We'll integrate later" is the plan for ERP write-back on financial actions.

Minimum entry artefact: Stage 2 pack (data inventory, model matrix, eval plan) plus one-page integration candidate list.

Exit criteria

Declare Stage 3 complete only when all exit checks pass:

Artefacts (minimum set)

Artefact	Source topic	Pass test
Capability map + target-state views	08	Business/application/data/integration/security/technology aligned; gaps named
ADR set (≥5 decisions)	08	Identity, residency, logging, model hosting, integration pattern documented
HLD with non-functionals	08	Latency, availability, RTO/RPO, tenancy, cost envelope explicit
API design + test strategy	15	Versioning, auth, prompt/RAG regression in CI
CI/CD pipeline outline	15	Environments, secrets, rollback, eval gate on merge
Landing-zone fit note	16	Account/subscription model, network, IAM, GPU capacity
Env topology + DR sketch	16	Prod/non-prod isolation; regional residency
Integration map + contracts	24	SoR, sync/async, idempotency, DLQ/replay per write path
Failure-mode notes	24	Timeout duplicate, partial failure, legacy throttle documented

Knowledge checks

• Answer ≥10/12 randomly chosen questions from topics 08, 15, 16, and 24 without notes.
• Explain one negative case (platform-as-product confusion, integration without idempotency, EA theatre) with client-relevant example.
• Draw C4 context + container for practice use case in 20 minutes with ADR references.

Behavioural checks

• You have blocked at least one design choice on non-functional or integration grounds—not only model preference.
• Peer reviewer confirms artefacts are filed in pattern library with sector tag.

Exit is not "I drew a diagram in Lucidchart." Exit is review-ready architecture pack.

Capability map

Stage 3 spans four numbered topics (08, 15, 16, 24). Topic 08 sets enterprise framing; 15–16 deliver build and host; 24 connects to systems of record.

Topic 08 — Enterprise Architecture

Capability: Place AI in TOGAF-aligned views—business, application, data, integration, security, technology—via capability maps, target-state transitions, non-functionals, and ADRs; distinguish platform vs product ownership.

You know it when: You defend target-state container diagram in EA review with traceability to capabilities and NFRs—not vendor logo placement.

Core deliverables: Capability map, target-state views, ADR set, HLD with non-functionals.

Deep link: Enterprise Architecture

Topic 15 — Software Engineering

Capability: Ship reliable AI services—REST/GraphQL APIs, auth, clean architecture, CI/CD, containers, and AI-specific testing (prompt regression, RAG golden sets, load, security).

You know it when: Prompt change triggers CI eval failure before merge—and rollback path is documented.

Core deliverables: API design sketch, test strategy, CI pipeline outline.

Deep link: Software Engineering

Topic 16 — Cloud and Platform Engineering

Capability: Deploy on hyperscaler landing zones with identity, networking, environment separation, GPU capacity planning, IaC, observability, DR, and multi-cloud tradeoffs without resume-driven architecture.

You know it when: You explain why EU banking workload uses private endpoints, CMK, and fixed region—and what breaks if someone enables public egress.

Core deliverables: Landing-zone fit note, env topology, DR sketch.

Deep link: Cloud and Platform Engineering

Topic 24 — Integration and Enterprise Systems

Capability: Integrate AI with ERP, CRM, core banking, ITSM, IdP, DMS via versioned APIs and events; choose sync vs async; implement idempotency, retries, DLQ, and legacy coexistence.

You know it when: Timeout on ticket creation does not produce duplicate ServiceNow incidents—and replay runbook exists.

Core deliverables: Integration map, API contract list, failure-mode notes.

Deep link: Integration and Enterprise Systems

Topics in this stage (quick index)

8. Enterprise Architecture
9. Software Engineering
10. Cloud and Platform Engineering
11. Integration and Enterprise Systems

Recommended practice sequence

Sequence A — Standard (4 weeks, ~8–10 hours/week)

Week	Focus	Outputs due
1	Topic 08 + Architecture Guide skim	Capability map + target-state C4 + 5 ADRs
2	Topic 15	API sketch + test strategy + CI outline with eval gate
3	Topic 16	Landing-zone fit + network/IAM diagram + DR sketch
4	Topic 24	Integration map + idempotency design + failure modes

Sequence B — Live engagement crash (2 weeks)

Use when staffed mid-build with weak architecture artefacts:

1. Days 1–2: Topic 08 HLD and NFR workshop—block build until ADRs exist.
2. Days 3–4: Topic 24 integration map and SoR matrix—before any write API.
3. Week 2: Topics 15 + 16 CI path and landing-zone controls.
4. Parallel: Stage 4 security/privacy review after Stage 3 pack draft—not in parallel without HLD.

Rule: No production traffic until integration failure modes and platform controls are written—not verbal.

Sequence C — Integration-heavy vs platform-heavy paths

Integration-heavy (servicing, ERP write-back): Week 1 topic 24 + 08 integration view; week 2 topic 15 API/idempotency; week 3 topic 16 network to on-prem ERP.

Platform-heavy (internal copilot, read-only RAG): Week 1 topics 08 + 16; week 2 topic 15 CI/eval; week 3 topic 24 read integrations only.

Integration with Guide and 8D

Stage 3 capability	Guide / reference
Solution architecture patterns	Architecture Guide
Delivery and release	Delivery Guide
Data and retrieval boundaries	Data & Knowledge
Methodology spine	8D Framework — Design, Develop, Deploy
Trust gates	Stage 4 topics 17–19 after architecture pack

Deep-link rule: Learning Map teaches judgement; Guide walks delivery steps. Link and produce artefacts—do not duplicate full Guide chapters in notes.

Common failure modes

Failure mode	How it shows up	Fix
Stage 3 before Stage 2	VPC and GPU quotes before data inventory	Block architecture review until readiness + eval exist
EA theatre	Pretty diagrams; no ADRs or NFRs	Topic 08 ADR template; attach numbers to latency/availability
Platform vs product blur	App team owns landing zone hacks	Topic 08 RACI; platform provides runway, product owns services
Demo CI only	Unit tests; no prompt/RAG regression	Topic 15 golden-set gate on merge
Shared prod secrets in dev	Same API key across envs	Topic 16 env separation + secret rotation
Public egress by default	LLM calls from open subnet	Topic 16 private endpoints + egress allow-list
Happy-path integration	Duplicate tickets on timeout	Topic 24 idempotency keys + DLQ
Sync call to ERP	30s LLM + 45s ERP = UX death	Topic 24 async + correlation ID
GPU capacity surprise	Fine-tune queue blocks inference	Topic 16 capacity plan; separate pools
Multi-cloud resume	Three clouds, triple ops tax	Topic 16 explicit tradeoff ADR
Integration without SoR	AI updates CRM; ERP still truth	Topic 24 system-of-record matrix
NFR hand-waving	"Highly available" with no RTO	Topic 08 NFR table with measurable targets

Stage 3 anti-pattern: the integration duplicate

A servicing assistant creates ServiceNow incidents when users report billing errors. Pilot handles 400 requests/day. Under load, ERP timeout rate hits 12%; retry logic creates duplicate tickets—1,840 duplicates in six weeks; operations spend £95K cleaning data; trust in AI programme collapses.

Stage 3 antidote: Idempotency keys, async pattern with status polling, DLQ + replay runbook (topic 24)—designed before write integration goes live.

Stage 3 anti-pattern: landing zone bypass

Team deploys RAG stack in personal cloud subscription to "move fast." Production review finds no CMK, no private link, shared admin account, US region for EU data. Full redeploy to enterprise landing zone: 14 weeks, £220K rework.

Stage 3 antidote: Landing-zone fit note and env topology (topic 16) week one—even for pilot, in approved non-prod subscription.

Stage 3 anti-pattern: prompt ship without CI

Engineers edit system prompt in production Friday afternoon. Monday: citation format breaks for regulatory quotes; 23% regression on golden set; no rollback package. Manual revert takes 9 hours; compliance logs incident.

Stage 3 antidote: Topic 15 CI with prompt version pin and eval threshold block on merge.

Manager review rubric (Stage 3 gate)

Dimension	Red	Amber	Green
EA views	Single diagram	Two views	Capability map + target state + ADRs
Non-functionals	Adjectives only	Partial numbers	Latency, availability, RTO/RPO, residency
Software delivery	No test strategy	Unit tests only	API contract + AI regression in CI
Cloud/platform	Sandbox account	Landing zone named	IAM, network, DR, GPU plan documented
Integration	Read-only assumed	Write without idempotency	SoR matrix + sync/async + failure modes
Platform vs product	Unclear ownership	RACI draft	Signed platform/product split

Green on ≥5/6 dimensions → recommend Stage 4 trust-and-control review for that workstream.

Competency proof

When claiming Stage 3 complete:

1. Submit architecture pack (artefact table above) to peer, EA, or manager.
2. 45-minute challenge session: NFR trade-offs, integration failure walk-through, cloud control checklist.
3. Optional: Competency test prompts for Stage 3.
4. File anonymised artefacts in team pattern library.

What comes next

Stage 4 asks: How do we secure, govern, and comply? Do not advance until Stage 3 exit criteria are met—or document explicit risk acceptance on integration write paths and platform gaps (logged with sponsor).

Output

Stage 3 portfolio deliverables (engagement pack minimum):

• Capability map and target-state architecture views (topic 08)
• ADR set and HLD with non-functionals (topic 08)
• API design sketch and test strategy with AI-specific checks (topic 15)
• CI/CD pipeline outline with eval gates (topic 15)
• Landing-zone fit note and env topology (topic 16)
• DR sketch and residency statement (topic 16)
• Integration map, API contracts, failure-mode notes (topic 24)

Stage 3 completion checklist

• Stage 2 exit criteria met or risk acceptance logged
• Capability map and target-state views reviewed with EA or equivalent
• ≥5 ADRs cover identity, residency, logging, hosting, integration
• Non-functionals have numbers—not only "secure and scalable"
• CI includes prompt/RAG regression before merge
• Landing zone, IAM, and network paths documented for pilot
• Integration map marks SoR, auth, sync/async, idempotency per system
• Failure modes and DLQ/replay documented for write paths
• Platform vs product ownership explicit
• Artefacts filed in pattern library; peer review completed

Key takeaways

• Stage 3 outcome is review-ready enterprise design—views, build, host, integrate—not infrastructure enthusiasm.
• Topics 08, 15, 16, 24 are interdependent; integration and platform choices belong in ADRs, not hallway decisions.
• Non-functionals and failure modes are where AI programmes die in production—design them before Stage 4 checklists.
• Platform engineering provides guardrails; product teams own application SLOs—blurring roles creates rework.
• Common failure is Stage 3 before Stage 2 or write integration without idempotency—both are expensive to fix live.
• Pair this stage with the Architecture Guide for delivery depth.

What to do next

1. If new to the map, read How to use this Learning Map for study method (90–180 min per topic).
2. Begin with Enterprise Architecture—frame target state before CI or VPC details.
3. Pair topic 08 with the Architecture Guide for pattern library.
4. When exit criteria pass, continue to Trust and control.