Skip to Content
Cloud Engineering Academy
13. Microsoft-to-AWS Migration

Migration assessment and portfolio discovery

Build a trustworthy inventory of a Microsoft estate, map dependencies, classify each application with the 7 Rs, group applications into waves, and produce the business-case numbers a bank's investment committee will accept, using AWS Transform and a small C# planning tool.

intermediate⏱ 2 h 30 min🟢 FreeSAP-C03SAA-C03

Assumes: .NET 10 LTS · AWS Transform (discovery tool, assessment) · AWS SDK for .NET v4 · AWS CDK v2 (C#) · Terraform AWS provider v6 · Region us-east-1. Verified against official sources on 2026-11-18.

Learning objectives

By the end of this lesson you can:

  • Explain what a migration assessment must produce (inventory, dependencies, strategy per application, waves, business case) and why each output exists.
  • Use the AWS Transform discovery tool and the assessment workflow to collect and analyse data from a VMware or Hyper-V estate, and name the older AWS tools it replaces.
  • Classify applications with the 7 Rs using explicit, auditable rules instead of gut feel.
  • Turn a dependency list into migration waves with a short C# program, including how to treat dependency cycles.
  • Build a business case with the right cost lines (and the cost lines people forget), and store discovery evidence safely.

Prerequisites

Why this matters in banking

Harbourline Bank has been told: "exit the Slough data centre by the end of next year." Nobody can say how many servers are in it. The CMDB lists 410 servers; the virtualisation platform shows 530 virtual machines; finance pays licences for 62 SQL Server instances, and the database team can name only 41. A payments batch that runs on the last working day of the quarter lives on a server that is not in any list.

An assessment is what prevents the "forgotten quarter-end server" outage. It is also the first piece of evidence a change board and a regulator will ask for: what do you run, what depends on what, who owns it, how critical it is, and why did you choose this path for this application. A bank that migrates without this ends up discovering dependencies in production, at the worst possible moment.

The idea in plain language

An assessment answers five questions, in order:

  1. What do we have? A trustworthy inventory of servers, databases, applications and their owners.
  2. What talks to what? Network and application dependencies. A server you move without its dependencies breaks.
  3. What should happen to each application? One of the 7 Rs, chosen by rules.
  4. In what order? Waves: groups of applications that move together, ordered by dependency and risk.
  5. Does it pay off? A business case: the cost of staying versus the cost of moving and running on AWS.

Each answer feeds the next. A wave plan built on a bad inventory is just a confident-looking mistake.

Analogy: Before a bank closes a branch it counts the safe deposit boxes, checks who holds keys, lists the standing orders that pay out of that branch, and decides which customers move to which new branch and in which week. Skipping the count does not remove the boxes; it only means you find them after the building is locked.

The 7 Rs, briefly

RMeaningHarbourline example
RetireSwitch it offA 2014 FX rate viewer nobody has opened in a year
RetainLeave it where it is, deliberatelyA card-scheme HSM integration tied to a regulated data centre cage
RehostLift and shift as-isA Windows service running a nightly statement batch
RelocateMove the hypervisor layer as-isA VMware cluster moved to an AWS-hosted VMware service ⚠ VERIFY current AWS option
RepurchaseReplace with SaaSA self-hosted intranet on SharePoint 2016 replaced by a SaaS product
ReplatformMove with small changesSQL Server 2016 to Amazon RDS for SQL Server
RefactorRe-architectA WCF and Web Forms portal rewritten for .NET 10 on containers

A dedicated lesson in this module covers the 7 Rs in depth; this lesson uses them as the output of a rule set.

What problem the AWS tooling solves

NeedAWS tool (status 2026-11-18)Honest limits
Collect server data without agents (VMware)AWS Transform discovery tool: a virtual appliance (OVA) deployed in your VMware environment. Reads inventory from vCenter, and reaches VMs over SSH, WinRM (which also inventories SQL Server) and SNMP. Hourly collection by defaultAgentless means it needs credentials and network reach to every guest. Physical servers and non-VMware platforms use other inputs
Analyse and build a business caseAWS Transform assessment: takes discovery exports and produces cost analysis, right-sizing recommendations and wave suggestionsInputs are accepted from the discovery tool, RVTools, CMDB exports, Migration Evaluator and partner tools, so the quality of the answer is the quality of the data you give it ⚠ VERIFY the exact list of accepted formats
Old discovery toolsApplication Discovery Service and Migration Hub: closed to new customers on 2025-11-07Existing customers may still use them; do not start a new programme on them
Hyper-V estatesAWS has published a workflow for Microsoft Hyper-V discovery and migration with AWS Transform⚠ VERIFY the current scope before relying on it
Database inventoryDMS Fleet Advisor reached end of support in May 2026 (see Database migration)Use the discovery tool's SQL Server inventory and Migration Evaluator ⚠ VERIFY

The discovery tool is worth a note for banks: its design keeps collected data on the appliance and does not need internet access. You download an export to a workstation and upload it to AWS only if you choose to. That fits a regulated estate where "where did the inventory go?" is itself a risk question.

Microsoft / Azure comparison

You know (Microsoft/Azure)AWS equivalentWhat's different
Azure Migrate: Discovery and assessment (appliance)AWS Transform discovery tool (OVA appliance) and assessmentBoth use an on-premises appliance. AWS's output is an assessment package (workbook, report and presentation) and the data format is an open portfolio format partners also use
Azure Migrate dependency analysisNetwork connection data from the discovery toolDependencies are inferred from observed connections, so a monthly batch job needs a long enough collection window
Azure Migrate business caseAWS Transform assessment business caseCompare both vendors' assumptions; each tool defaults to its own cloud
Azure Cost Management / TCO calculatorAWS Pricing Calculator, Migration Evaluator ⚠ VERIFY current nameAlways model licence-included against bring-your-own-licence (see Windows and SQL Server licensing)
CMDB (ServiceNow)Still your source of truth for ownershipDiscovery data tells you what exists; the CMDB tells you who owns it. You need both

Architecture

Security-boundary view. The appliance needs read access to vCenter and a credential on each guest, which is a privileged footprint. Treat those credentials like production secrets: read-only accounts, vaulted, rotated after the collection window, and every use logged. The exported inventory is sensitive (hostnames, IPs, software versions, a vulnerability map of the bank), so it lives in an encrypted bucket with Block Public Access, versioning and access logging, and the upload to AWS needs an explicit approval.

Step-by-step implementation

Fix the scope and the questions

Write down the in-scope estate (data centres, clusters, business units) and the decision you are supporting: "exit Slough" is a different assessment from "modernise the payments platform". List the quarter-end and year-end events, because the collection window must contain one cycle of each critical batch.

Collect

Deploy the discovery appliance in the VMware environment (sizing from the AWS guide: 4 vCPU, 16 GB RAM, 35 GB disk, access to vCenter on port 443). Provide read-only guest credentials, let it collect hourly, and run it long enough to see a full business cycle. Four weeks is a common minimum; for quarter-end jobs you may need more ⚠ VERIFY your own batch calendar.

Reconcile with the CMDB and finance

Join discovery data with the CMDB (owner, criticality, data classification) and the licensing records. Every difference is a finding: servers in discovery but not in the CMDB are "unknown owners" and must be resolved before wave planning.

Classify with rules

Apply the 7 R rules in code (below). Record the rule that fired, so a reviewer can disagree with the rule instead of with an opinion.

Plan waves

Order applications by dependency. Put low-risk, well-understood applications first to build confidence (a pilot wave), and the core ledger last. Handle dependency cycles by moving the cycle together.

Build the business case

Run the AWS Transform assessment on the discovery export and cross-check with your own model. Present the cost of staying (including the hardware refresh you avoid), the cost of the migration programme itself, and the target run cost under two or three licensing scenarios.

AWS Console instructions

AWS Transform is used through its own web application, and an administrator enables it first ⚠ VERIFY the current enablement path in the AWS Transform user guide, because it has changed since launch.

  • Console → AWS Transform (or the Transform web application, signed in with IAM Identity Center) → create a workspace → choose the migration assessment workflow.
  • Upload the discovery export (or connect a supported source) and review the inventory it reports back before accepting any recommendation.
  • Download the business-case package and store it in the evidence bucket (see the IaC section).

For the evidence bucket: Console → S3 → Create bucket, keep Block all public access on, enable Bucket Versioning and Default encryption with SSE-KMS, then Server access logging to a separate log bucket.

AWS CLI

AWS Transform assessment is driven from its web application; the CLI is useful around it for evidence handling.

# Create the evidence bucket (us-east-1 needs no LocationConstraint).
aws s3api create-bucket --bucket hl-m13-assessment-evidence-123456789012 \
  --profile learn-sandbox --region us-east-1

# Block every form of public access.
aws s3api put-public-access-block --bucket hl-m13-assessment-evidence-123456789012 \
  --public-access-block-configuration BlockPublicAcls=true,IgnorePublicAcls=true,BlockPublicPolicy=true,RestrictPublicBuckets=true \
  --profile learn-sandbox

# Keep every version of every export; assessments are audit evidence.
aws s3api put-bucket-versioning --bucket hl-m13-assessment-evidence-123456789012 \
  --versioning-configuration Status=Enabled --profile learn-sandbox

# Upload an export with server-side encryption using KMS and tag it for ownership.
aws s3 cp ./portfolio-export.zip s3://hl-m13-assessment-evidence-123456789012/2026-11/portfolio-export.zip \
  --sse aws:kms --profile learn-sandbox

The bucket name must be globally unique, so replace the account number with your own.

Infrastructure as Code

An evidence bucket with encryption, versioning, no public access and a retention rule. The same shape is used by later lessons for the runbook evidence.

EvidenceBucketStack.cs
using Amazon.CDK;
using Amazon.CDK.AWS.KMS;
using Amazon.CDK.AWS.S3;
using Constructs;

namespace Harbourline.Migration.Infra;

public sealed class EvidenceBucketStack : Stack
{
    public EvidenceBucketStack(Construct scope, string id, IStackProps? props = null)
        : base(scope, id, props)
    {
        var key = new Key(this, "EvidenceKey", new KeyProps
        {
            EnableKeyRotation = true,
            Description = "hl-m13 migration assessment evidence",
            RemovalPolicy = RemovalPolicy.RETAIN
        });

        var logs = new Bucket(this, "AccessLogs", new BucketProps
        {
            BlockPublicAccess = BlockPublicAccess.BLOCK_ALL,
            Encryption = BucketEncryption.S3_MANAGED,
            EnforceSSL = true,
            RemovalPolicy = RemovalPolicy.RETAIN
        });

        _ = new Bucket(this, "Evidence", new BucketProps
        {
            BlockPublicAccess = BlockPublicAccess.BLOCK_ALL,
            Encryption = BucketEncryption.KMS,
            EncryptionKey = key,
            EnforceSSL = true,
            Versioned = true,
            ServerAccessLogsBucket = logs,
            ServerAccessLogsPrefix = "evidence/",
            // Keep old versions for a year, then expire them (no infinite retention).
            LifecycleRules =
            [
                new LifecycleRule
                {
                    NoncurrentVersionExpiration = Duration.Days(365),
                    AbortIncompleteMultipartUploadAfter = Duration.Days(7)
                }
            ],
            RemovalPolicy = RemovalPolicy.RETAIN
        });

        // Inside a Stack, Amazon.CDK.Tags.Of(this) resolves to the stack's own property, so qualify it.
        Amazon.CDK.Tags.Of(this).Add("Project", "cea-lab");
        Amazon.CDK.Tags.Of(this).Add("Lab", "m13-assessment");
        Amazon.CDK.Tags.Of(this).Add("Environment", "learn");
        Amazon.CDK.Tags.Of(this).Add("Owner", "your-name");
    }
}

Complete code

A single-file planner: it reads a portfolio CSV, applies the 7 R rules, computes waves from the dependency graph and prints a plan. It uses only the base class library, so it runs with dotnet run and no AWS account.

The sample input, portfolio.csv (all fictional):

portfolio.csv
id,name,tier,runtime,vendor,saas_alternative,windows_only_blockers,usage_90d,regulatory_hold,change_appetite,depends_on
A01,Branch Portal,2,netfx48,custom,false,true,184000,false,high,A04;A05
A02,FX Rate Viewer,4,netfx48,custom,false,false,0,false,low,
A03,Intranet,4,sharepoint,cots,true,false,9100,false,low,
A04,Customer Master API,1,netfx48,custom,false,false,920000,false,medium,A06
A05,Statement Batch,2,windows-service,custom,false,false,31000,false,low,A06
A06,Core Ledger DB,1,sqlserver,cots,false,false,4100000,false,low,
A07,Card HSM Bridge,1,appliance,cots,false,false,780000,true,low,A06
A08,Reporting Cubes,3,sqlserver,cots,false,false,12000,false,medium,A06;A09
A09,Data Mart ETL,3,windows-service,custom,false,false,22000,false,medium,A08
Program.cs
using System.Globalization;

if (args.Length != 1)
{
    Console.Error.WriteLine("usage: dotnet run -- portfolio.csv");
    return 1;
}

var apps = PortfolioReader.Read(args[0]);
var plan = WavePlanner.Build(apps, maxPerWave: 3);

Console.WriteLine("== Strategy per application ==");
foreach (var a in apps.OrderBy(a => a.Id, StringComparer.Ordinal))
{
    var (strategy, rule) = Classifier.Classify(a);
    Console.WriteLine($"{a.Id}  {a.Name,-22} {strategy,-11} rule: {rule}");
}

Console.WriteLine();
Console.WriteLine("== Waves ==");
for (var i = 0; i < plan.Waves.Count; i++)
{
    var names = string.Join(", ", plan.Waves[i].Select(a => a.Name));
    Console.WriteLine($"Wave {i + 1}: {names}");
}

foreach (var cycle in plan.Cycles)
{
    Console.WriteLine($"Dependency cycle, move together: {string.Join(" <-> ", cycle.Select(a => a.Name))}");
}

return 0;

// ---- model ----------------------------------------------------------------

public sealed record App(
    string Id, string Name, int Tier, string Runtime, string Vendor,
    bool SaasAlternative, bool WindowsOnlyBlockers, long Usage90d,
    bool RegulatoryHold, string ChangeAppetite, IReadOnlyList<string> DependsOn);

public static class PortfolioReader
{
    public static IReadOnlyList<App> Read(string path)
    {
        var lines = File.ReadAllLines(path).Skip(1).Where(l => !string.IsNullOrWhiteSpace(l));
        return lines.Select(Parse).ToList();
    }

    private static App Parse(string line)
    {
        var c = line.Split(',');
        if (c.Length != 11) throw new FormatException($"Expected 11 columns, got {c.Length}: {line}");
        return new App(
            c[0], c[1], int.Parse(c[2], CultureInfo.InvariantCulture), c[3], c[4],
            bool.Parse(c[5]), bool.Parse(c[6]), long.Parse(c[7], CultureInfo.InvariantCulture),
            bool.Parse(c[8]), c[9],
            c[10].Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries));
    }
}

// ---- 7 R rules: first match wins, and the rule name is recorded -----------

public static class Classifier
{
    public static (string Strategy, string Rule) Classify(App a)
    {
        if (a.Usage90d == 0) return ("Retire", "R1 no use in 90 days");
        if (a.RegulatoryHold) return ("Retain", "R2 regulatory or hardware hold");
        if (a.Vendor == "cots" && a.SaasAlternative) return ("Repurchase", "R3 SaaS alternative exists");
        if (a.Runtime == "vmware-cluster") return ("Relocate", "R4 move the hypervisor layer");
        if (a.Vendor == "custom" && a.Runtime == "netfx48" && a.ChangeAppetite == "high")
            return ("Refactor", "R5 custom .NET Framework with budget to change");
        if (a.Runtime is "sqlserver" || (a.Vendor == "custom" && a.ChangeAppetite == "medium"))
            return ("Replatform", "R6 managed service gives most of the value");
        return ("Rehost", "R7 default: lift and shift, modernise later");
    }
}

// ---- waves: layered topological sort (Kahn) --------------------------------

public sealed record Plan(IReadOnlyList<IReadOnlyList<App>> Waves, IReadOnlyList<IReadOnlyList<App>> Cycles);

public static class WavePlanner
{
    public static Plan Build(IReadOnlyList<App> apps, int maxPerWave)
    {
        var byId = apps.ToDictionary(a => a.Id);
        // An application can only move once everything it depends on has moved or is in the same wave.
        var remaining = apps.ToDictionary(a => a.Id, a => a.DependsOn.Where(byId.ContainsKey).ToHashSet());
        var waves = new List<IReadOnlyList<App>>();

        while (remaining.Count > 0)
        {
            var ready = remaining.Where(kv => kv.Value.Count == 0).Select(kv => byId[kv.Key])
                // Lower-risk first: higher tier number means less critical.
                .OrderByDescending(a => a.Tier).ThenBy(a => a.Id, StringComparer.Ordinal).ToList();

            if (ready.Count == 0) break; // only cycles are left

            foreach (var chunk in ready.Chunk(maxPerWave))
                waves.Add(chunk);

            foreach (var a in ready) remaining.Remove(a.Id);
            foreach (var deps in remaining.Values) deps.ExceptWith(ready.Select(r => r.Id));
        }

        var cycles = new List<IReadOnlyList<App>>();
        if (remaining.Count > 0)
        {
            // Everything left depends on something left. Group the leftovers as one move-together set.
            var group = remaining.Keys.Select(k => byId[k]).OrderBy(a => a.Id, StringComparer.Ordinal).ToList();
            cycles.Add(group);
            waves.Add(group);
        }

        return new Plan(waves, cycles);
    }
}

Expected output (abridged): A06 Core Ledger DB is classified Replatform and appears in wave 1 because it has no dependencies, but a banker would not want the core ledger first. That is a deliberate lesson, covered in the exercises: a topological order says what is possible, and risk says what is wise.

Code explained line by line

  1. PortfolioReader.Read skips the header row and parses each line into an immutable App record. It throws on a wrong column count, because silently skipping a malformed row would drop an application from the plan.
  2. Classifier.Classify is a chain of early returns. Order matters: retire is checked before everything, so a dead application is never "replatformed". It returns the rule identifier with the strategy, which is the audit trail.
  3. WavePlanner.Build copies each application's dependencies into a mutable set. A set whose count is zero means "all my dependencies are already placed".
  4. OrderByDescending(a => a.Tier) puts tier 4 (least critical) ahead of tier 1. That is the "easy first" heuristic, applied within a layer, not across layers.
  5. ready.Chunk(maxPerWave) splits a large layer into waves of at most maxPerWave applications. Wave size is a change-management limit, not a technical one.
  6. When no application is ready but some remain, every remaining application is waiting on another remaining one: a cycle. The planner reports it as one move-together set. In real portfolios a cycle usually means two systems share a database or call each other synchronously, and they must move in the same cut-over.
  7. byId.ContainsKey filters dependencies on things outside the portfolio. Log those as "external dependencies" in a real tool; they are often where surprises live (a partner SFTP endpoint, a mainframe).

Security considerations

⚠ Learning shortcut — not for production

The exercises use a hand-written CSV and a local program. A real assessment collects data with privileged read access to a production estate, and the output is a map of the bank's weak points. Production practice: a named data owner approves the collection, guest credentials are least privilege and short-lived, the appliance sits in a management network segment, exports are classified as confidential, and the upload to any cloud service goes through the same approval as other confidential data.

  • Data residency and AI features. Assessment tooling may use generative features or process data in a particular Region. Record where the processing happens and obtain approval before uploading ⚠ VERIFY the data-handling statement in the current AWS Transform documentation. This is a compliance review item, not something the lesson can sign off.
  • Evidence integrity. Use versioning and a bucket policy that denies deletes. For regulated evidence consider S3 Object Lock (see S3 protection, Object Lock and Macie).
  • Credentials. Do not paste guest passwords into spreadsheets. Use your vault and revoke them when collection ends.

Banking use case

Harbourline runs a four-week collection across 530 VMs. The reconciliation finds 47 VMs with no CMDB owner; 12 are idle test servers (Retire), and 3 host the forgotten quarter-end reconciliation job. The classifier produces: 38 Retire, 11 Retain (HSM bridge, two card-scheme gateways, pending a hardware review), 6 Repurchase, 260 Rehost, 90 Replatform, 14 Refactor, and the rest unclassified pending owner input. Waves start with a pilot of low-tier internal applications, move the customer-facing tier in the middle, and place the core ledger and its dependants in the last two waves with a long rollback window. The business case shows the three licensing scenarios side by side, which leads directly to the licensing lesson.

Common mistakes

  • Treating the CMDB as truth. It is out of date by default. Why: it is updated by people. Fix: reconcile with observed data and make every mismatch a ticket.
  • A collection window too short. A job that runs quarterly never appears in a two-week capture. Fix: calendar-driven collection, plus interviews for known periodic jobs.
  • Choosing the R by technology only. Business appetite and regulation matter as much as runtime. Fix: include regulatory_hold and change_appetite in the rules.
  • Wave plans that follow only the graph. The core ledger can move first technically and should not. Fix: add risk and a pilot wave.
  • A business case without the migration programme cost. Staff, parallel running, testing and training often outweigh the infrastructure line.
  • Forgetting data transfer and dual running. You pay for both estates during the overlap.

Troubleshooting

SymptomLikely causeFix
Discovery appliance sees VMs but no dependenciesGuest credentials or WinRM/SSH access missingCheck firewall rules to the guest ports and the service account rights
SQL Server instances missing from inventoryWinRM account lacks rights on the instanceGrant the read-only inventory permissions your DBA approves
Assessment shows a very low cost for the targetRight-sizing used average CPU on idle hosts, or licensing assumed BYOLCompare utilisation percentile settings; model licensing explicitly
Planner reports one huge cycleShared database or chatty servicesSplit by data ownership; treat it as one move-together set until proven otherwise
FormatException from the CSV readerCommas inside a fieldQuote fields or switch to a proper CSV parser

Cost and cleanup

Cost: free. The planner is local. The AWS Transform assessment has no cited charge in the sources used here ⚠ VERIFY before use. The S3 evidence bucket and the KMS key cost a few cents per month: the KMS key is about USD 1 per month until deleted ⚠ VERIFY current price.

# Empty and delete the evidence bucket (versioned: delete versions too, or use the console "Empty" action).
aws s3 rm s3://hl-m13-assessment-evidence-123456789012 --recursive --profile learn-sandbox
aws s3api delete-bucket --bucket hl-m13-assessment-evidence-123456789012 --profile learn-sandbox

# CDK or Terraform users: destroy through the tool instead.
# cdk destroy    or    terraform destroy

# Confirm nothing tagged Project=cea-lab remains.
aws resourcegroupstaggingapi get-resources --tag-filters Key=Project,Values=cea-lab --profile learn-sandbox

A KMS key is scheduled for deletion with a waiting period of 7 to 30 days; it keeps billing until then.

Exercises

  • 🟢 Guided: Save the sample CSV, run the planner, and write down which rule classified each application. Change A02's usage_90d to 100 and explain what happens to its strategy.
  • 🟡 Challenge: Add a rule: any application with tier 1 that is not Retain must never appear in wave 1 or the pilot. Adjust the planner so the first wave holds only tier 3 and 4 applications, even if dependencies would allow more.
  • 🔴 Live problem: The CIO asks for "the total number of servers we can switch off by June." Discovery shows 530 VMs, the CMDB shows 410, and finance shows 62 SQL licences. Write the one-page plan for reconciling these numbers, naming the owners, the evidence and the point at which you are willing to put a number in front of the committee.

Assignment

Produce assessment-pack.md in your portfolio repository: your own 12-application fictional portfolio CSV, the planner output, a list of the five rules you would add for your organisation, and a one-page business-case outline listing every cost line (including the ones people forget).

Solutions

Knowledge check

Interview questions

  • How do you find the servers nobody remembers? Combine passive network and process observation across a full business cycle with CMDB and finance reconciliation, then treat every unowned item as a finding with a deadline.
  • How do you decide between Rehost and Replatform? Rehost when the deadline and risk dominate and the application cannot change; replatform when a managed service removes a licence or operations cost with little code change. Record the trade-off.
  • What would make you refuse to put a date on a migration? An inventory that has not been reconciled, a collection window that missed a critical cycle, or a core dependency with no owner.

Certification practice

Completion checklist

  • I can list the five outputs of an assessment and why each exists
  • I ran the planner and can explain which rule fired for each application
  • I can explain why a wave plan needs risk as well as dependencies
  • I ran the cleanup steps and confirmed nothing tagged Project=cea-lab remains

Key takeaways

  • An assessment is five answers: inventory, dependencies, strategy, waves, business case.
  • Collect across a full business cycle and reconcile with the CMDB; every mismatch is a finding.
  • Use rules, not opinions, for the 7 Rs and record which rule fired.
  • Dependencies decide what is possible; risk decides what is sensible.
  • AWS Transform replaces Migration Hub and Application Discovery Service for new customers.

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