Skip to Content
Cloud Engineering Academy
12. High Availability & Disaster Recovery

Well-Architected reviews for a banking API

Run a Well-Architected review of a banking API, focusing on the Reliability pillar and the Financial Services Industry Lens, record risks in the Well-Architected Tool, and turn high-risk items into a tracked improvement plan with C# tooling.

intermediate⏱ 2 h 🟢 FreeSAA-C03SOA-C03DOP-C02SAP-C03

Assumes: .NET 10 LTS · AWS SDK for .NET v4 (AWSSDK.WellArchitected) · AWS CLI v2 · AWS CDK v2 (C#) · Region us-east-1. Verified against official sources on 2026-11-18.

Learning objectives

By the end of this lesson you can:

  • Explain the purpose of a Well-Architected review: a structured conversation that finds risks, not an audit or a certificate.
  • Describe the Reliability pillar's four areas and its design principles, and map each to lessons in this module.
  • Use the AWS Well-Architected Tool to create a workload, apply the Financial Services Industry Lens, answer questions, read high and medium risk items and save a milestone.
  • Prepare evidence, run a review workshop and produce an improvement plan with owners and dates.
  • Automate parts of the process with C#: read answers from the Tool, summarise risk, and fail a pipeline on unaccepted high risks.

Prerequisites

Why this matters in banking

Before the Accounts API goes live, Harbourline's architecture board wants to know: "What are the biggest reliability risks, who owns them, and when will they be fixed?" A review that produces a list of named risks with owners and dates is far more useful than a diagram everyone nods at. A year later, when the board asks what changed, the milestones in the Tool show how many high-risk items were closed.

The review also forces conversations that never happen otherwise: "Who decided the RTO?" "What happens if the sanctions-screening provider is slow, not down?" "When was the last restore test?" The answers, or the lack of them, are the findings.

A Well-Architected review is a self-assessment to improve a workload. It is not an external audit, it does not certify compliance, and you should not describe it that way to regulators. Your risk, compliance and security functions decide what counts as evidence for regulatory purposes.

The idea in plain language

The AWS Well-Architected Framework is a set of best practices organised into six pillars: operational excellence, security, reliability, performance efficiency, cost optimisation and sustainability. For each pillar there are questions ("How do you design your workload to withstand component failures?") with a list of choices (best practices). You tick the ones you follow. The Tool then flags the questions where you follow few or none as high-risk issues (HRI) or medium-risk issues (MRI) and suggests an improvement plan with links.

A lens adds guidance for a specific industry or technology. The Financial Services Industry Lens (publication date 27 January 2026 per the AWS documentation) adds best practices, aimed at financial institutions, for security, data privacy and resiliency, and for building transparency and auditability into your AWS environment.

Analogy: A building survey. The surveyor walks through with a checklist, asks how the building handles fire, flooding and power cuts, and writes up the cracks to fix first. The survey doesn't make the building safe; the repairs do. A lens is the extra checklist for a particular kind of building, such as a hospital or a bank vault.

What problem the review solves

ProblemHow the review helps
Teams have never compared their design with a shared standardA common question set gives a shared vocabulary
Risks live in people's headsAnswers and notes are recorded; risks get owners
Improvement is ad hocPrioritised HRI list and milestones show progress over time
Regulatory conversations need a structured approachThe record is one input to your internal resilience evidence (not proof of compliance)
Fixes aren't tied to the AWS ecosystemEach question links to guidance and relevant services

Honest limits:

  • It is only as good as the honesty of the answers. People tick boxes optimistically; ask for evidence for each answer.
  • It is not exhaustive. It will not find a subtle race condition in your payment code.
  • Questions evolve. AWS updates the framework and lenses; a review from three years ago reflects old questions ⚠ VERIFY the current framework version in the Tool.
  • The review does not fix anything. The improvement plan does, if it is resourced.

The Reliability pillar

Reliability is the ability of a workload to perform its intended function correctly and consistently, and to recover quickly from failure. The pillar's design principles, in plain language:

  1. Automatically recover from failure: detect and respond to failure with automation, not people reading pagers.
  2. Test recovery procedures: rehearse failures and restores (game days, FIS, restore testing).
  3. Scale horizontally to increase aggregate availability: many small resources instead of one big one.
  4. Stop guessing capacity: use auto scaling and measure.
  5. Manage change through automation: infrastructure as code, pipelines, safe deployments.

The pillar groups its best practices into four areas. This table maps them to the work in this module, which is the evidence you bring to the review.

AreaWhat it asks aboutWhere you built or learned it
FoundationsService quotas, network topology, availability across AZs, connectivityMulti-AZ, load balancing and Auto Scaling lessons; Networking module
Workload architectureService design, how components interact, how to prevent and tolerate failureResilience patterns lesson; Caching with fail-open
Change managementMonitoring, scaling to demand, deployments, change automationPerformance and cost; pipelines in Module 9
Failure managementBackups, fault isolation, failover, testing reliability, disaster recoveryDatabase failover, AWS Backup, FIS, Game days

Microsoft / Azure comparison

You know (Microsoft/Azure)AWS equivalentWhat's different
Azure Well-Architected Framework and Well-Architected Review assessmentAWS Well-Architected Framework and the Well-Architected ToolBoth are question-based; the AWS Tool stores workloads, answers, risks and milestones in your account
Azure Advisor recommendationsTrusted Advisor, Resilience Hub, the Tool's improvement planAdvisor reads your configuration; the review captures design and process answers too
Azure Architecture Center and industry guidanceIndustry lenses such as the Financial Services Industry LensA lens plugs into the same Tool
Architecture review boards and design authoritiesReview workshops plus the milestone historyThe Tool provides a repeatable template for the board's questions

Architecture

Security-boundary view: the workload record contains design details and known weaknesses, which is sensitive. Restrict access to the Tool with IAM (read for reviewers, write for the review owner), share workloads across accounts only when needed, and treat exports as confidential. Do not paste secrets or customer data into notes.

Step-by-step implementation

Define scope and owners

Pick a single workload: the Accounts API in production, including its database, cache, queues and the DR design, not "the bank". Name a review owner, a facilitator and one person per area (platform, application, data, operations).

Gather evidence before the workshop

Collect architecture diagrams, the IaC repository, SLO dashboards, alarm lists, backup and restore reports, game-day timelines, Resilience Hub assessments, the last post-incident reviews, and quota reports. Evidence beats opinion.

Create the workload and add lenses

In the Well-Architected Tool create a workload (environment, Regions, review owner) and add the Well-Architected Framework lens and the Financial Services Industry Lens.

Run the workshop

Take the Reliability pillar first. For each question, read the choices, agree on what is actually true today, select the matching choices, and write a note with evidence or the missing action. Disagreement is a finding in itself.

Read the risks

Review HRIs and MRIs. Challenge each: is it real, is it already accepted by the business, what is the cost of fixing it? Mark accepted risks explicitly with an owner and a review date.

Create the improvement plan

Turn each HRI into a ticket in your backlog with an owner, a due date and the expected outcome. Prioritise by risk, effort and dependency.

Save a milestone and schedule the next review

Save a milestone so you can compare later. Repeat after significant changes (new Region, new data store, new payment scheme) and at least annually.

AWS Console instructions

  • Create a workload: Console → AWS Well-Architected Tool → Workloads → Define workload. Enter name, description, review owner, environment (Production or Pre-production), Regions, then choose lenses on the next page.
  • Add the FSI lens: open the workload → Lenses → Add lens → choose Financial Services Industry Lens from the Lens Catalog.
  • Answer questions: open the workload → select the lens → Start reviewing → pick a pillar → for each question select the best practices you follow, add Notes, choose Save and next. Use Question does not apply only with a written reason.
  • Read the improvement plan: Improvement plan tab → filter by pillar and risk (High, Medium) → open the question for guidance and links.
  • Milestone: Milestones → Save milestone, give it a name such as 2026-11-pre-go-live.
  • Report: Generate report to download a PDF summary for the architecture board.

AWS CLI

# List the lenses available to your account to find the Financial Services Industry Lens alias.
aws wellarchitected list-lenses \
  --query "LensSummaries[].{Alias:LensAlias,Name:LensName,Version:LensVersion}" \
  --region us-east-1 --profile learn-sandbox

# Create a workload with the framework lens (add the FSI lens by its alias from the list above).
aws wellarchitected create-workload \
  --workload-name hl-m12-accounts-api \
  --description "Harbourline Accounts API: lab review" \
  --environment PREPRODUCTION \
  --aws-regions us-east-1 us-west-2 \
  --review-owner you@example.com \
  --lenses wellarchitected \
  --tags Project=cea-lab,Lab=m12-wa-review \
  --region us-east-1 --profile learn-sandbox

# Associate an additional lens later (alias comes from list-lenses).
aws wellarchitected associate-lenses --workload-id WORKLOAD_ID \
  --lens-aliases FSI_LENS_ALIAS --region us-east-1 --profile learn-sandbox

# See the reliability questions and their current risk.
aws wellarchitected list-answers --workload-id WORKLOAD_ID \
  --lens-alias wellarchitected --pillar-id reliability \
  --query "AnswerSummaries[].{Q:QuestionTitle,Risk:Risk,Id:QuestionId}" \
  --region us-east-1 --profile learn-sandbox

# Record an answer: choose the best practices that apply (ids come from get-answer).
aws wellarchitected update-answer --workload-id WORKLOAD_ID \
  --lens-alias wellarchitected --question-id QUESTION_ID \
  --selected-choices CHOICE_ID_1 CHOICE_ID_2 \
  --notes "Multi-AZ ECS service; restore test report 2026-10; see game-day timeline." \
  --region us-east-1 --profile learn-sandbox

# Overall risk counts per pillar.
aws wellarchitected get-lens-review --workload-id WORKLOAD_ID --lens-alias wellarchitected \
  --query "LensReview.PillarReviewSummaries[].{Pillar:PillarName,Risks:RiskCounts}" \
  --region us-east-1 --profile learn-sandbox

# Save a milestone.
aws wellarchitected create-milestone --workload-id WORKLOAD_ID \
  --milestone-name pre-go-live --region us-east-1 --profile learn-sandbox

# Cleanup.
aws wellarchitected delete-workload --workload-id WORKLOAD_ID \
  --region us-east-1 --profile learn-sandbox

WORKLOAD_ID, QUESTION_ID and choice IDs are placeholders you read from earlier command output. Use --lens-alias wellarchitected for the core framework; the FSI lens alias must be taken from list-lenses ⚠ VERIFY. The --environment values are PRODUCTION and PREPRODUCTION; the list of required flags can change, so check aws wellarchitected create-workload help.

Infrastructure as Code

Workloads can be declared as code so the review record is reproducible, though the answers themselves are best written by humans in the Tool or by script.

infra/cdk/WellArchitectedStack.cs
using Amazon.CDK;
using Amazon.CDK.AWS.WellArchitected;
using Constructs;

namespace Harbourline.Ha.Infra;

public sealed class WellArchitectedStack : Stack
{
    public WellArchitectedStack(Construct scope, string id, IStackProps props) : base(scope, id, props)
    {
        _ = new CfnWorkload(this, "AccountsApi", new CfnWorkloadProps
        {
            WorkloadName = "hl-m12-accounts-api",
            Description = "Harbourline Accounts API: Well-Architected review (lab)",
            Environment = "PREPRODUCTION",
            ReviewOwner = "you@example.com",
            AwsRegions = new[] { "us-east-1", "us-west-2" },
            Lenses = new[] { "wellarchitected" }, // add the FSI lens alias from list-lenses ⚠ VERIFY
            Tags = new[]
            {
                new CfnWorkload.TagsItemsProperty { Key = "Project", Value = "cea-lab" },
                new CfnWorkload.TagsItemsProperty { Key = "Lab", Value = "m12-wa-review" },
                new CfnWorkload.TagsItemsProperty { Key = "Environment", Value = "learn" }
            }
        });
    }
}

Property names follow the CloudFormation AWS::WellArchitected::Workload resource ⚠ VERIFY in your CDK version. Lens aliases for AWS-official lenses can differ from their display names.

Complete code

The Tool stores answers; your pipeline and your risk register need them as data. Three small pieces: a review model that works offline (so you can rehearse a review without AWS), a gate that fails on unaccepted high risks, and a reader that pulls the real answers from the Tool.

src/Harbourline.Ha.Review/ReviewModel.cs
namespace Harbourline.Ha.Review;

public enum Risk { None, Medium, High, Unanswered }

public enum Area { Foundations, WorkloadArchitecture, ChangeManagement, FailureManagement }

public sealed record ReviewItem(
    string Id,
    Area Area,
    string Question,       // your own paraphrase of the topic, not AWS question text
    Risk Risk,
    string Evidence,       // link or file name; empty means opinion only
    string Owner,
    DateOnly? DueDate,
    bool AcceptedByBusiness,
    DateOnly? AcceptanceReviewDate);

public sealed record RiskSummary(int High, int Medium, int Unanswered, int Accepted);

public static class ReviewAnalysis
{
    public static RiskSummary Summarise(IEnumerable<ReviewItem> items)
    {
        var list = items.ToList();
        return new RiskSummary(
            High: list.Count(i => i.Risk == Risk.High),
            Medium: list.Count(i => i.Risk == Risk.Medium),
            Unanswered: list.Count(i => i.Risk == Risk.Unanswered),
            Accepted: list.Count(i => i.AcceptedByBusiness));
    }

    /// <summary>
    /// Problems that should fail a pipeline or block a go-live: high risks with no owner, due date or valid acceptance,
    /// unanswered questions, and answers claimed without evidence.
    /// </summary>
    public static IReadOnlyList<string> GateProblems(IEnumerable<ReviewItem> items, DateOnly today)
    {
        var problems = new List<string>();
        foreach (var i in items)
        {
            if (i.Risk == Risk.Unanswered)
                problems.Add($"{i.Id}: question not answered.");

            if (i.Risk == Risk.High)
            {
                var acceptedAndCurrent = i.AcceptedByBusiness &&
                                         i.AcceptanceReviewDate is { } d && d >= today;
                var planned = !string.IsNullOrWhiteSpace(i.Owner) && i.DueDate is not null;
                if (!acceptedAndCurrent && !planned)
                    problems.Add($"{i.Id}: high risk has neither a valid acceptance nor an owner and due date.");
                if (i.AcceptedByBusiness && i.AcceptanceReviewDate is { } r && r < today)
                    problems.Add($"{i.Id}: risk acceptance expired on {r:yyyy-MM-dd}.");
            }

            if (i.Risk == Risk.None && string.IsNullOrWhiteSpace(i.Evidence))
                problems.Add($"{i.Id}: marked low risk but no evidence recorded.");
        }
        return problems;
    }

    /// <summary>Markdown improvement plan: high first, then medium, ordered by due date.</summary>
    public static string ImprovementPlan(IEnumerable<ReviewItem> items) =>
        string.Join(Environment.NewLine,
            new[] { "| Risk | Area | Item | Owner | Due |", "|---|---|---|---|---|" }.Concat(
                items.Where(i => i.Risk is Risk.High or Risk.Medium)
                     .OrderByDescending(i => i.Risk == Risk.High)
                     .ThenBy(i => i.DueDate ?? DateOnly.MaxValue)
                     .Select(i => $"| {i.Risk} | {i.Area} | {i.Question} | {(string.IsNullOrWhiteSpace(i.Owner) ? "UNASSIGNED" : i.Owner)} | {i.DueDate?.ToString("yyyy-MM-dd") ?? "none"} |")));
}
src/Harbourline.Ha.Review/ToolReader.cs
using Amazon;
using Amazon.WellArchitected;
using Amazon.WellArchitected.Model;

namespace Harbourline.Ha.Review;

/// <summary>Reads reliability answers for a workload from the Well-Architected Tool.</summary>
public sealed class ToolReader(IAmazonWellArchitected client)
{
    public async Task<IReadOnlyList<(string QuestionId, string Title, Risk Risk)>> ReadReliabilityAsync(
        string workloadId, string lensAlias = "wellarchitected", CancellationToken ct = default)
    {
        var results = new List<(string, string, Risk)>();
        string? next = null;
        do
        {
            var page = await client.ListAnswersAsync(new ListAnswersRequest
            {
                WorkloadId = workloadId,
                LensAlias = lensAlias,
                PillarId = "reliability",
                NextToken = next
            }, ct);

            foreach (var a in page.AnswerSummaries)
                results.Add((a.QuestionId, a.QuestionTitle, MapRisk(a.Risk?.Value)));

            next = page.NextToken;
        } while (!string.IsNullOrEmpty(next));

        return results;
    }

    private static Risk MapRisk(string? value) => value switch
    {
        "HIGH" => Risk.High,
        "MEDIUM" => Risk.Medium,
        "NONE" or "NOT_APPLICABLE" => Risk.None,
        _ => Risk.Unanswered   // UNANSWERED or anything unexpected
    };

    public static IAmazonWellArchitected Create(RegionEndpoint? region = null) =>
        new AmazonWellArchitectedClient(region ?? RegionEndpoint.USEast1);
}
src/Harbourline.Ha.Review/Program.cs
using Harbourline.Ha.Review;

// Offline rehearsal: Harbourline's Accounts API self-assessment (fictional answers).
var today = new DateOnly(2026, 11, 18);
var items = new List<ReviewItem>
{
    new("F1", Area.Foundations, "Service quotas tracked for both Regions", Risk.Medium,
        "quota-report-2026-10.csv", "platform-lead", new DateOnly(2026, 12, 15), false, null),
    new("W1", Area.WorkloadArchitecture, "Timeouts, retries with jitter and circuit breakers on all outbound calls", Risk.None,
        "docs/resilience-pipeline.md", "api-lead", null, false, null),
    new("C1", Area.ChangeManagement, "Canary deployment with automatic rollback", Risk.Medium,
        "", "release-manager", new DateOnly(2027, 1, 31), false, null),
    new("R1", Area.FailureManagement, "Backups restored and validated on a schedule", Risk.None,
        "restore-testing-report-2026-10.md", "dba-lead", null, false, null),
    new("R2", Area.FailureManagement, "Cross-Region failover rehearsed within the last 6 months", Risk.High,
        "", "", null, false, null),
    new("R3", Area.FailureManagement, "Dependency on sanctions-screening provider has a degraded-mode design", Risk.High,
        "adr-021.md", "payments-lead", null, true, new DateOnly(2027, 3, 1))
};

var summary = ReviewAnalysis.Summarise(items);
Console.WriteLine($"High {summary.High}, Medium {summary.Medium}, Unanswered {summary.Unanswered}, Accepted {summary.Accepted}");
Console.WriteLine();
Console.WriteLine(ReviewAnalysis.ImprovementPlan(items));
Console.WriteLine();

var problems = ReviewAnalysis.GateProblems(items, today);
foreach (var p in problems) Console.WriteLine($"GATE: {p}");
Environment.ExitCode = problems.Count == 0 ? 0 : 1;

Sample output:

High 2, Medium 2, Unanswered 0, Accepted 1

| Risk | Area | Item | Owner | Due |
|---|---|---|---|---|
| High | FailureManagement | Cross-Region failover rehearsed within the last 6 months | UNASSIGNED | none |
| High | FailureManagement | Dependency on sanctions-screening provider has a degraded-mode design | payments-lead | none |
| Medium | Foundations | Service quotas tracked for both Regions | platform-lead | 2026-12-15 |
| Medium | ChangeManagement | Canary deployment with automatic rollback | release-manager | 2027-01-31 |

GATE: R2: high risk has neither a valid acceptance nor an owner and due date.

The package is AWSSDK.WellArchitected (4.x). Property names such as AnswerSummaries, QuestionTitle and Risk follow the service API; confirm them against the installed package ⚠ VERIFY.

Code explained line by line

  1. Risk and Area model what the Tool gives you: risk levels (high, medium, none, unanswered) and the four Reliability areas.
  2. ReviewItem records more than the Tool does: an evidence pointer, an owner, a due date and a business acceptance with a review date. These are what turn a finding into an actionable, governable item.
  3. The question text is a paraphrase of the topic, in your own words. Use the Tool for the official question wording and do not copy it into other documents.
  4. Summarise counts risks for dashboards and milestones.
  5. GateProblems encodes governance rules: no unanswered questions; a high risk needs either a valid, unexpired acceptance or an owner and a due date; a "no risk" claim needs evidence.
  6. Acceptance expires. A risk accepted in 2025 and never reviewed is a hidden risk.
  7. ImprovementPlan orders high before medium and then by due date, putting unassigned items visibly at the top of the list as UNASSIGNED.
  8. ToolReader pages through ListAnswers (the service returns pages), and maps the service's risk strings to the local enum, treating anything unexpected as Unanswered so that surprises fail safe.
  9. In Program.cs the exit code is non-zero when the gate finds problems, so the same program can run in a pipeline before a release.

Security considerations

⚠ Learning shortcut — not for production

The lab review is a one-person exercise in a sandbox, with notes typed into the Tool and no sign-off. A production review involves several owners, evidence links, a recorded decision for each accepted risk, restricted access to the workload record, and approval by the architecture and risk functions.

  • The review record is sensitive. It lists known weaknesses. Restrict write access to the review owner, read access to reviewers, and avoid sharing workloads outside the organisation without need.
  • No secrets or personal data in notes. Notes are free text and are copied into reports.
  • Integrity of evidence. Link evidence that cannot be quietly edited (reports in a versioned bucket, tickets, pipeline run IDs).
  • Separation of duties. The person who owns the fix should not alone decide to accept the risk. Acceptance needs a business owner.
  • Regulatory claims. Do not describe "no high risks in the Tool" as compliance. Say what you assessed, against which framework version, on which date.
  • Frequency and drift. After major changes, the previous review no longer describes the system. Tie re-review to change events (new Region, new data store, new payment scheme) as well as the calendar.

Banking use case

Harbourline runs a pre-go-live review for the Accounts API with the Framework lens and the Financial Services Industry Lens, then yearly. Participants: product owner, engineering lead, platform, DBA, security, operational resilience, and an observer from internal audit. A worked example of a reliability workshop outcome:

Finding (topic)Evidence foundRiskAction
Multi-AZ for compute and dataIaC, Aurora and ECS across three AZsNoneKeep; re-check after changes
Timeouts and retries on outbound callsResilience pipeline in code, tested with fault-injecting handlerNoneNone
Sanctions-screening provider failure modeDesign says queue and hold; never testedHigh (accepted for 90 days)Game day in Q1, owner payments lead
Cross-Region failover tested within six monthsOnly a tabletop, last AprilHighLive failover in test by end of January
Quotas for RegionsSpreadsheet, last updated 8 months agoMediumAutomate with Service Quotas alarms
Deployment safetyRolling updates; no automatic rollbackMediumAdd canary with rollback in release pipeline

The board's view: two high risks, one accepted until a named date, and dated actions on the others. Next year's milestone should show them closed or still open for a reason. The architecture board sees a trend, not a snapshot.

The Financial Services Industry Lens is part of this conversation, since it frames security, data privacy and resiliency best practices for financial institutions and the transparency and auditability of the environment. Read the lens questions in the Tool itself; do not rely on a summary in a lesson, since the lens is versioned and updated by AWS ⚠ VERIFY the current content.

Common mistakes

  • Reviewing "the bank". Scope to one workload with owners who can answer.
  • Answering from memory. Use evidence; if you cannot find it, the honest answer is "no".
  • Running the review as a tick-box exercise by one person. The value is the discussion across platform, application, data and operations.
  • Accepting risk with no end date. Acceptance must be time-limited and owned by someone with authority.
  • Treating the review as a one-off. Systems change; schedule re-reviews and save milestones.
  • Ignoring medium risks forever. Medium items accumulate into large ones; set a regular burn-down.
  • Copying AWS question text into your own documents and calling it your standard. Reference the Tool and write your own policy language.
  • Calling it an audit. It is a self-assessment; auditors and regulators need different evidence.

Troubleshooting

SymptomLikely causeFix
FSI lens not listedLens not in the catalog for your account or Region, or the alias differsRun list-lenses; check the Lens Catalog in the console ⚠ VERIFY availability
update-answer fails with a validation errorChoice IDs are for another question or lensUse get-answer to read the valid choice IDs for that question
AccessDenied creating a workloadIAM user lacks wellarchitected:CreateWorkloadGrant the specific actions to the review owner role
Risk does not change after selecting choicesAnswer not saved, or notes saved onlyRe-open the question and use Save; confirm with list-answers
Cannot add a lens to an existing workloadLens version or sharing issue (custom lens)Check lens status and permissions; for custom lenses, ensure the lens is shared with your account
Milestone shows different counts than the live reviewLive review has changed since the milestoneExpected: milestones are snapshots; compare by date
Pipeline gate fails unexpectedlyAcceptance expired or a question is unansweredReview the problem list; renew or fix the item
Reader returns fewer questions than the consolePagination not followedLoop on NextToken as in ToolReader

Cost and cleanup

Cost: free. The AWS Well-Architected Tool has no charge for the service itself ⚠ VERIFY on the current pricing page. The C# review model runs locally with no AWS account. Creating a workload takes no running resources, but tidy up so that the lab does not clutter your account:

# Delete the lab workload (this removes its answers and milestones).
aws wellarchitected delete-workload --workload-id WORKLOAD_ID \
  --region us-east-1 --profile learn-sandbox

# If you used CDK or Terraform:
cdk destroy --all --profile learn-sandbox
# terraform destroy

# Confirm nothing tagged Project=cea-lab remains.
aws resourcegroupstaggingapi get-resources --tag-filters Key=Project,Values=cea-lab \
  --region us-east-1 --profile learn-sandbox --query "ResourceTagMappingList[].ResourceARN"

Export a PDF report before deleting if you want to keep the lab's results.

Exercises

  • 🟢 Guided: Run the offline review program. Then add evidence and an owner for R2, set its due date in the future, and rerun to see the gate pass. Explain why the output changed.
  • 🟡 Challenge: Write xUnit v3 tests for GateProblems: an expired acceptance, a high risk with owner but no due date, a "None" risk with no evidence, an unanswered item, and a clean list. Add a sixth rule of your own (for example, medium risks older than 180 days) with a test.
  • 🔴 Live problem: The architecture board refuses to approve go-live because the Tool shows four high risks. The product owner argues three are "theoretical". Prepare for the meeting: how you will challenge each risk with evidence, which you would propose to accept (with owner, expiry and compensating controls), which must be fixed first, and what you will not claim about compliance.

Assignment

Run a Reliability review of one Harbourline service (real in your sandbox, or fictional on paper). Deliver: the scoped workload description, evidence list, the risk table (using the C# model), the improvement plan with owners and dates, the list of accepted risks with expiry dates, and the planned date of the next review. Commit it to your portfolio repository under docs/reviews/.

Solutions

Knowledge check

Interview questions

  • How would you run a Well-Architected review for a payments API? Scope one workload, gather evidence, hold a workshop with platform, application, data, security and operations, answer questions by pillar starting with reliability and security, record notes and evidence, turn high risks into tickets with owners, save a milestone, and re-review after major changes.
  • What is the difference between a high-risk and a medium-risk item? The Tool derives it from which best practices are in place; high means significant best practices are missing for that question. How you handle them is a business decision: fix, accept with expiry, or mitigate.
  • How do you stop the review becoming theatre? Require evidence, involve the people who build and operate the system, track findings to closure, and compare milestones.
  • How does the FSI Lens help a bank? It adds financial-services guidance for security, data privacy and resiliency and for transparency and auditability, which helps structure the conversation with risk and compliance. It does not replace regulatory obligations.

Certification practice

Completion checklist

  • I can name the four areas and five design principles of the Reliability pillar
  • I can explain what a lens is and what the FSI Lens adds
  • I ran the offline review model and made the gate pass for the right reason
  • I deleted the lab workload and confirmed nothing is left behind

Key takeaways

  • A Well-Architected review is a structured self-assessment that produces named, owned and dated risks.
  • Reliability has four areas: foundations, workload architecture, change management and failure management; this module gave you evidence for each.
  • The Financial Services Industry Lens adds financial-services guidance; read it in the Tool, and never treat the review as proof of compliance.
  • Evidence beats opinion; acceptances must be owned and expire.
  • Automate what you can: read answers with the API and gate releases on unmanaged high risks.

Further reading

Independent learning resource — not affiliated with, endorsed or sponsored by Amazon Web Services. AWS and related marks are trademarks of Amazon.com, Inc. or its affiliates. All banking data in examples is fictional. Sample architectures are for learning and are not automatically compliant with GDPR, PCI DSS or any banking regulation.

On this page