Architecture & Capstone

Why This Phase Exists

You have spent nine phases accumulating individual capabilities. You can provision networks. You can deploy compute. You can configure databases. You can orchestrate containers. You can automate infrastructure. You can secure workloads. You can monitor systems. You can optimize costs. Each of those skills is necessary. None of them is sufficient.

The difference between an engineer who knows AWS services and an architect who designs AWS solutions is the ability to combine services into coherent systems that solve business problems under real-world constraints. Constraints like budget. Constraints like regulatory compliance. Constraints like team size. Constraints like time-to-market. Constraints like performance requirements that conflict with cost targets. Constraints like reliability goals that demand redundancy you would rather not pay for.

Phase 10 is where you stop thinking about individual services and start thinking about systems. You stop asking "how do I use this service?" and start asking "which combination of services solves this problem most effectively given these constraints?" You stop following tutorials and start making architectural decisions where every choice involves trade-offs, and every trade-off requires justification.

This is the phase where AWS gives you a formal framework for evaluating your own work: the Well-Architected Framework. It is where you study the architecture patterns that recur across thousands of production workloads. It is where you learn how organizations move existing workloads to AWS systematically rather than chaotically. It is where you build data platforms that turn raw information into business intelligence. It is where you integrate machine learning without becoming a data scientist. And it is where you prove your mastery by designing and building a production-grade system from scratch in the Capstone project.

After Phase 10, you do not just know AWS. You think in AWS. You can walk into a meeting, hear a business problem, and architect a solution on a whiteboard within the hour. That is the level this phase targets.

What You Will Master

By the end of Phase 10, you will be able to:

• Apply the six pillars of the AWS Well-Architected Framework to evaluate any architecture for operational excellence, security, reliability, performance efficiency, cost optimization, and sustainability
• Use the Well-Architected Tool to conduct formal reviews that identify high-risk issues and generate prioritized improvement plans
• Select the appropriate architecture pattern (three-tier, serverless, event-driven, microservices, CQRS, saga) for a given set of business requirements
• Design migration strategies using the 7 Rs framework, choosing the right approach based on application characteristics, business urgency, and technical constraints
• Build data lake architectures on AWS using Lake Formation, Glue, Athena, and QuickSight that transform raw data into actionable analytics
• Integrate AWS AI/ML services (Rekognition, Comprehend, SageMaker, Bedrock) into application architectures without requiring deep machine learning expertise
• Design and build a complete production-grade system that demonstrates mastery across all ten phases: networking, compute, storage, security, automation, monitoring, and architecture

Modules in This Phase

The Progressive Path

This phase follows a deliberate progression from evaluation framework through patterns and strategies to applied synthesis.

Module 69 establishes the evaluation lens. Before you design new architectures, you need a rigorous framework for assessing whether an architecture is good. Not "does it work?" because working is the minimum bar. The Well-Architected Framework asks harder questions: will it recover when things fail? Does it protect data at every layer? Can you deploy changes without downtime? Are you paying for resources you do not use? Will it scale when demand doubles? The six pillars provide the vocabulary and mental models for reasoning about architecture quality. Every architectural decision in Modules 70 through 74 should be evaluated through this lens.

Module 70 gives you the pattern library. Once you can evaluate architectures, you need a repertoire of proven solutions to draw from. Three-tier applications for traditional web workloads. Serverless architectures for event-driven workloads with variable traffic. Microservices for large teams that need independent deployment. Event-driven systems for loose coupling and asynchronous processing. CQRS for read-heavy workloads with different read and write scaling requirements. The Saga pattern for distributed transactions that cannot use two-phase commit. The Strangler Fig pattern for incremental modernization. Each pattern has a problem it solves well and a context in which it fails. Module 70 teaches you to match patterns to problems.

Module 71 addresses the reality that most organizations are not building on AWS from scratch. They have existing workloads running on-premises or in other clouds. Migration is a discipline with its own strategies, tools, and phased approach. The 7 Rs provide a decision framework for what to do with each application. The migration services provide the tooling. The phased approach (assess, mobilize, migrate, optimize) provides the project structure. You will understand how to build a business case, discover existing workloads, plan the migration sequence, and execute the migration with minimal disruption.

Module 72 builds the analytics layer. Every application generates data. Most organizations store that data but extract limited value from it. A data lake architecture centralizes structured and unstructured data from multiple sources into a governed repository where it can be cataloged, transformed, and analyzed at scale. Lake Formation handles governance. Glue handles ETL and cataloging. Athena and Redshift Spectrum handle SQL analytics. QuickSight handles visualization. Kinesis handles real-time streaming. Together they form the modern analytics platform that turns operational data into business intelligence.

Module 73 introduces machine learning as an architectural capability rather than a separate discipline. AWS provides AI services that require no ML expertise (Rekognition, Comprehend, Textract), a full ML platform for custom models (SageMaker), and managed foundation models for generative AI (Bedrock). You learn when to use each tier, how to integrate them into application architectures, and how to evaluate cost and latency trade-offs. This is not a machine learning course. This is an architecture course that includes ML as one of the tools available for solving business problems.

Module 74 is the Capstone. You choose one of four pre-defined project options at varying complexity levels and build it end to end. The Capstone requires you to demonstrate competency across all ten phases: networking, compute, databases, security, IaC, CI/CD, monitoring, cost management, and architecture. You produce a deployed application, IaC code, architecture documentation, a Well-Architected review, a cost estimation, and a disaster recovery plan. This is your portfolio piece. This is proof of mastery.

Services You Will Command

Architecture and Governance

• AWS Well-Architected Tool — Formal workload reviews against six pillars with improvement planning
• AWS Well-Architected Lenses — Domain-specific extensions (Serverless, SaaS, Data Analytics, ML, IoT)
• AWS Architecture Center — Reference architectures and pattern documentation

Migration and Transfer

• AWS Migration Hub — Centralized tracking for migration projects across multiple tools
• AWS Application Discovery Service — Automated inventory and dependency mapping for on-premises workloads
• AWS Migration Evaluator — Business case and TCO analysis for migration planning
• AWS Application Migration Service (MGN) — Lift-and-shift server replication with automated cutover
• AWS Database Migration Service (DMS) — Homogeneous and heterogeneous database migration with CDC
• AWS Schema Conversion Tool (SCT) — Database schema and code conversion between engines
• AWS Snow Family — Offline data transfer at petabyte scale (Snowcone, Snowball, Snowmobile)
• AWS DataSync — Online data transfer between on-premises storage and AWS
• AWS Transfer Family — Managed SFTP/FTPS/FTP for S3 and EFS

Data Lakes and Analytics

• AWS Lake Formation — Governed data lake setup with fine-grained access control
• AWS Glue — Serverless ETL with crawlers, jobs, Data Catalog, and schema registry
• Amazon Athena — Serverless SQL queries against S3 data using standard SQL
• Amazon Redshift Spectrum — Query data lake from Redshift without loading
• Amazon QuickSight — Serverless BI with ML-powered insights and SPICE engine
• Amazon Kinesis Data Streams — Real-time data streaming for custom processing
• Amazon Data Firehose — Managed delivery of streaming data to S3, Redshift, OpenSearch
• Amazon MSK — Managed Apache Kafka for enterprise streaming workloads

Machine Learning and AI

• Amazon SageMaker — Full ML lifecycle: notebooks, training, tuning, deployment, pipelines
• Amazon Bedrock — Managed foundation models (Claude, Titan, Llama) via API
• Amazon Rekognition — Image and video analysis (faces, objects, text, moderation)
• Amazon Comprehend — Natural language processing (sentiment, entities, topics)
• Amazon Textract — Document text and data extraction (forms, tables, signatures)
• Amazon Transcribe — Speech-to-text transcription with speaker identification
• Amazon Polly — Text-to-speech with neural voices
• Amazon Translate — Real-time language translation
• Amazon Personalize — Real-time personalization and recommendation
• Amazon Forecast — Time-series forecasting with AutoML
• Amazon Kendra — Intelligent enterprise search with NLP

Architecture Maturity Model

Phase 10 represents the transition from service operator to solution architect. This progression maps to a maturity model that reflects how architectural thinking develops:

┌─────────────────────────────────────────────────────────────────────┐
│                    ARCHITECTURE MATURITY MODEL                        │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   Level 1: Service User                                             │
│   "I can use individual AWS services"                               │
│   (Phases 1-4)                                                      │
│                                                                     │
│   Level 2: System Builder                                           │
│   "I can connect services into working systems"                     │
│   (Phases 5-7)                                                      │
│                                                                     │
│   Level 3: Operational Engineer                                     │
│   "I can run systems reliably and efficiently"                      │
│   (Phases 8-9)                                                      │
│                                                                     │
│   Level 4: Solution Architect                                       │
│   "I can design systems that balance competing constraints"         │
│   (Phase 10)                                                        │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

The Solution Architect level requires all previous levels. You cannot make good architectural trade-offs without understanding individual services (Level 1), knowing how they integrate (Level 2), and appreciating the operational implications (Level 3). Phase 10 synthesizes all of that knowledge into architectural judgment.

The Capstone as Proof of Mastery

The Capstone project in Module 74 is not a tutorial. There are no step-by-step instructions. You receive a project brief with business requirements, technical constraints, and quality expectations. You must:

1. Design the architecture (service selection, data flow, failure modes, scaling approach)
2. Implement the infrastructure (IaC code, CI/CD pipeline, security controls)
3. Deploy the application (working system in a real AWS account)
4. Document the decisions (architecture diagrams, trade-off rationale, cost estimates)
5. Review the result (formal Well-Architected review identifying risks and improvement areas)

The Capstone demonstrates that you can move from a blank whiteboard to a production-grade deployed system. This is the outcome that the entire 74-module curriculum has been building toward.

Phase Exam

After completing all six modules, you will take the Phase 10 Architecture & Capstone exam:

• 50 multiple-choice questions covering Well-Architected pillars, architecture patterns, migration strategies, data lake design, ML service selection, and system design principles
• 75 minutes time limit
• 70% pass threshold (35/50 correct)
• Questions emphasize architectural decision-making: selecting the right pattern for stated requirements, identifying Well-Architected violations, choosing migration strategies based on constraints, designing analytics pipelines for specific data characteristics, and integrating ML capabilities appropriately
• Expect scenario-based questions that present a business problem with constraints (budget, timeline, team skills, regulatory requirements) and ask you to select the architecture, service combination, or migration approach that best satisfies those constraints
• Trade-off analysis is heavily represented: questions will present options that are individually valid but require you to identify the best fit for the specific context described
• The Capstone project deliverables (architecture document, Well-Architected review, cost estimation) are evaluated separately from the exam