AI-Augmented Software Architecture
Architecting systems where AI is part of the system, not a feature bolted on
About this course
A long-form architecture programme for engineers moving into an architect role, rewritten around the assumption that AI is now inside the systems they design. It covers the classical ground properly — design patterns, non-functional requirements, microservices, event-driven architecture, domain modelling, data architecture, CI/CD, cloud, deployment and observability — and then asks, for each, what changes when part of the system is probabilistic.
It also gives real weight to the parts of an architect's job that are not technical: stakeholder management, storytelling, trust, feedback, consulting and leading with a systems view.
Nine core modules, two hands-on workshops, an individual case study, knowledge checks along the way, and a capstone in which you architect one AI-first system end to end and defend it.
What you’ll be able to do
- Design systems intent-first rather than screen-first, and know where agentic workflows belong and where they do not
- Apply classical design patterns and judge honestly how each holds up once part of the system is probabilistic
- Define non-functional requirements for AI systems — accuracy, latency, cost, guardrails — and argue the trade-offs between them
- Architect microservices, event-driven and reactive systems, and decide between a microservice and an agent
- Design domain models, contract-first APIs and semantic contracts that a model can call without ambiguity
- Choose a data and retrieval architecture deliberately, including when a vector database is the wrong answer
- Design GenAI security and governance: prompt injection, personal-data masking, guardrails, auditability
- Build CI/CD, cloud, deployment and release strategies, and extend them with LLMOps and continuous evaluation
- Instrument systems end to end with monitoring, tracing and telemetry across layers
- Do the non-technical half of the job: stakeholders, storytelling, trust, feedback, consulting and systems thinking
Before you start
What this course assumes you can already do.
- Several years of professional engineering experience, with ownership of a non-trivial component.
- Working knowledge of at least one of web, mobile or backend development at a senior level.
- Familiarity with microservices design principles — the course recaps them but assumes you have met them.
- Comfortable reading cloud architecture diagrams and CI/CD pipeline definitions.
- Some exposure to large language model APIs.
- Deep AI background is not required; the programme builds the AI-specific material.
The curriculum
Open any module to see its objective, every teaching topic, the practice brief and the checkpoint.
Recaps and reference material are included in the LMS. Optional elective sessions will be listed once their content is confirmed.
PART 1Architecture thinking and patterns
01Thinking Like an AI-First Architect
Make the shift the whole programme depends on: from designing components and screens to designing intents, conversations and outcomes — and then check which classical patterns still earn their place once a model is in the system.
- Programme kick-off: the AI-first architectConcept
- Thinking Like an AI‑First ArchitectConcept
- From Web & Mobile Architecture to Intent-Based SystemsConcept
- Architecture Design Patterns & Deep Dive (AI‑Augmented)Concept
- Clean Architecture with MVVM (AI-augmented): case studiesConcept
Re-architect one screen-shaped design as an intent
Take a feature you have designed or reviewed that is organised around screens or components. Redesign it around user intent and outcome, with the AI parts explicit, and then say honestly what got worse.
Knowledge checkpoint with explained answers
02Non-Functional Requirements, Performance and State
Define what "good enough" means for a system whose output varies between runs: accuracy, latency and cost as first-class requirements, plus the performance, caching and memory strategies that make those numbers achievable.
- NFRs and SAFE Agile Ecosystem (AI‑First Systems)Concept
- Strategies for Designing Scalable & High‑Performance Systems (App, Web & AI)Concept
- State Management & Caching (App, Web, Mobile & AI Systems)Concept
Write the non-functional requirements for one AI feature
Pick one AI-backed feature and write its non-functional requirements as numbers someone could hold you to — then show what you gave up to make each achievable.
Knowledge checkpoint with explained answers
PART 2System, data and security design
03Microservices, Reactive and Agentic Systems
Decide between a microservice and an agent on evidence, and design the asynchronous, event-driven substrate that long-running AI reasoning actually needs.
- Microservices & Agentic Systems – AI‑First ArchitectureConcept
- Reactive Architecture & Event‑Driven FoundationsConcept
Decide service or agent, then design the async path
Take one workflow and design it twice: as conventional microservices, and with an agent in it. Then design the event-driven substrate that the long-running version would need.
Knowledge checkpoint with explained answers
04Domain Modelling, Contracts and Data Architecture
Get the contracts right — between services, between domains, and between a model and the functions it is allowed to call — and choose a data and retrieval architecture that fits the questions being asked.
- Domain Modeling, APIs & Semantic ContractsConcept
- Data Architecture & Persistence StrategyConcept
- GraphQL – Design, Trade‑offs & Architectural ImpactConcept
Write the contract a model cannot misread
Design the domain model and contracts for one bounded context, then extend them into function-calling contracts and structured outputs a model can be held to. Finish with the data and retrieval decision.
Knowledge checkpoint with explained answers
05GenAI Security, Guardrails and Governance
Treat the model as an untrusted input surface: prompt injection, personal-data handling, guardrails, human-in-the-loop safety, and an audit trail that answers "why did it say that?".
- GenAI Security, Guardrails & GovernanceConcept
Attack your own AI feature, then govern it
Take an AI feature you have designed in this programme and attack it: prompt injection through every input path, including indirect injection through retrieved documents. Then write the governance position.
Knowledge checkpoint with explained answers
PART 3Delivery, operations and evaluation
06DevOps, CI/CD, Cloud and Deployment
Own the delivery path end to end: what DevOps is actually for, pipeline design, cloud platform and hosting choices for AI workloads, deployment strategies, release management and infrastructure as code.
- CI/CD Fundamentals & Tooling LandscapeConcept
- DevOps Foundations & Agile AlignmentConcept
- Cloud Fundamentals & Platform ServicesConcept
- Deployment Strategies & ResilienceConcept
- Release Management & ConfigurationConcept
- Infrastructure as Code (IaC) & Config SystemsConcept
Build the delivery path for an AI service
Design the full delivery path for one AI-backed service: pipeline, environments, cloud hosting choice, deployment strategy, release management and infrastructure as code.
Knowledge checkpoint with explained answers
07LLMOps, Continuous Evaluation and Observability
Operate an AI system: prompt versioning and drift, continuous evaluation in the pipeline, a quality engineering strategy that covers non-deterministic behaviour, and telemetry that lets you find the cause rather than guess it.
- LLMOps EssentialsConcept
- Quality Engineering (QE) – Testing Strategy, Value & AutomationConcept
- Monitoring & TelemetryConcept
Instrument an AI system so a regression is visible
Take one AI feature and build the operational story around it: prompt versioning, a continuous evaluation stage in the pipeline, a test strategy that works for non-deterministic output, and telemetry across every layer.
Knowledge checkpoint with explained answers
PART 4Workshops and assessments
08Workshops and Assessments
Apply the programme under time pressure: two hands-on workshops, an individual case study reviewed by a mentor, and four knowledge checks along the way.
- Workshop: Architecture & AI Pattern SelectionConcept
- Workshop: Cloud Deployment & CI/CD for AI‑First SystemsHands-on
- Workshop phase 2: AI-assisted DevOpsHands-on
- Individual case study: choose and apply an architecture patternHands-on
Re-architect a real system, then automate its delivery
The two workshop blocks, run as one continuous exercise: re-architect an existing single-page or multi-page application into an intent-driven, multi-agent-aware design across web and mobile contexts, then take a service from container to a running Kubernetes deployment and add AI-assisted acceleration to the pipeline.
Knowledge checkpoint with explained answers
PART 5The non-technical half of the job
09Stakeholders, Communication and Leading
Do the half of the architect's job that is not in the diagram: understand what each stakeholder actually wants, tell the story, build trust, give feedback that lands, consult rather than dictate, and hold the big picture.
- Agility in ActionConcept
- Stakeholder Understanding & ManagementConcept
- Storytelling & PresentationsConcept
- Building Trust & leading with ownershipConcept
- Big Picture UnderstandingConcept
- Consulting SkillsConcept
- Power of feedbackConcept
- SAFe in practiceConcept
- Learning from engineering leadersConcept
- Stakeholder management revisitedConcept
Run a real stakeholder conversation and review it honestly
Take a live architectural decision you need someone else to accept. Map the stakeholders, build the story, have the conversation, and then review what actually happened against what you planned.
Knowledge checkpoint with explained answers
Architect one AI-first system, end to end, and defend it
One system, carried from framing through to operations, with the decisions written down at each stage. The capstone joins the two workshops and the individual case study into one continuous architecture deliverable, so the trade-offs compound the way they do in real work.
Framing and pattern selection — Establish intent-driven framing and choose the patterns, per platform.
Non-functional requirements, contracts and data — Numbers you can be held to, and contracts a model cannot misread.
Service topology and security — The runtime shape of the system, and the assumption that the model is untrusted.
Delivery path — From commit to production, manually first.
AI-assisted acceleration, critically reviewed — Only after the manual phase, so the output can be judged.
Operations and evaluation — Prove you could run it and find a regression.
The defence — Present it to people who will disagree, and hold the argument.
Next course
Tell us about yourself or your team and we’ll let you know how and when you can take this course.