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

Network migration and hybrid architecture

Design the network that carries a long migration: plan non-overlapping address space, choose Site-to-Site VPN or Direct Connect, connect with Transit Gateway, share DNS in both directions with Route 53 Resolver, extend Active Directory, and handle latency and bandwidth while applications live in both worlds.

advanced⏱ 2 h 30 min🔴 Paid — optionalSAP-C03SAA-C03

Assumes: .NET 10 LTS · AWS CLI v2 · 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 why migrations run for months in a hybrid state and what the network must guarantee during that time.
  • Plan address space so on-premises, AWS and future ranges never overlap, and check it with code.
  • Choose between Site-to-Site VPN, AWS Direct Connect and both together, and size replication bandwidth honestly.
  • Wire up Route 53 Resolver inbound and outbound endpoints so on-premises and AWS resolve each other's names.
  • Design Active Directory coexistence (AWS Managed Microsoft AD, AD Connector, a trust to on-premises) and choose a workload-latency strategy for chatty applications.
  • Deploy the connectivity pieces with CDK (C#) or Terraform.

Prerequisites

Cost label: paid. VPN connections, Resolver endpoints and Direct Connect bill by the hour. Free alternative: design-only. Run cdk synth or terraform validate and the C# planner locally, and never apply the stacks, or deploy for under an hour.

Why this matters in banking

A migration is not a weekend; it is 12 to 24 months in which the ledger might be in the data centre while the customer portal is already in AWS. Every call between them crosses a network that did not exist before. If that network is slow, a page that made 40 database calls at 0.3 ms now makes them at 12 ms each, and a 12 ms page becomes half a second. If its address space overlaps, packets go to the wrong place. If its DNS is inconsistent, half the servers resolve the old database and half the new one, which is a data-integrity incident in a bank. If it is a single VPN tunnel and the tunnel flaps during month-end, a payments batch times out.

Plan the network first, because it is hard to change once applications depend on it.

The idea in plain language

A hybrid architecture needs four things to behave like one network:

  1. Addressing: no two sites use the same IP range, ever.
  2. Transport: an encrypted path (VPN) or a private circuit (Direct Connect) with enough bandwidth and the right redundancy.
  3. Name resolution: both sides can resolve the other's private names.
  4. Identity: staff and services authenticate the same way on both sides (Active Directory, Kerberos).

Analogy: Two bank buildings that share a customer base. They need distinct street numbers (addressing), a secure courier route or a private tunnel between them (transport), one phone directory that works in both (DNS), and one staff pass system (identity). Without any one of the four, staff walk between buildings and cannot get anything done.

What problem the AWS services solve

NeedAWS serviceHonest limits
Quick, encrypted connectivitySite-to-Site VPN: two tunnels per connection over the internet; IPsec; static or BGP routingEach tunnel is limited to about 1.25 Gbps; internet path means variable latency ⚠ VERIFY current limits. Use Transit Gateway with ECMP to aggregate tunnels ⚠ VERIFY
Predictable bandwidth and latencyAWS Direct Connect: dedicated (1, 10, 100 Gbps) or hosted connections through partnersLead time of weeks to months; physical redundancy (two locations) is your job; not encrypted by default (use MACsec or a VPN over it) ⚠ VERIFY options
Many VPCs and sitesAWS Transit GatewayPer-attachment and per-GB charges; route tables need care
DNS across the boundaryRoute 53 Resolver inbound and outbound endpoints with forwarding rulesEach endpoint is billed per ENI per hour; at least two IP addresses per endpoint in different AZs
Active DirectoryAWS Managed Microsoft AD, AD Connector, trust relationshipsSimple AD is in maintenance (announced 2026-06-30): do not plan on it. Managed AD bills per hour per edition ⚠ VERIFY
Bulk dataAWS DataSync, Snowball family ⚠ VERIFY current availability, DMSOver the wire: 10 TB at 1 Gbps with 70% usable is roughly 32 hours

Microsoft / Azure comparison

You know (Microsoft/Azure)AWS equivalentWhat's different
Azure VPN GatewaySite-to-Site VPN (virtual private gateway or Transit Gateway)AWS gives two tunnels per connection to two endpoints; configure both
ExpressRouteDirect ConnectSame idea: private circuit via a partner or a colocation. Resiliency models are published; follow them
Virtual WAN hubTransit GatewayRegional hub with route tables, attachments for VPCs, VPNs and Direct Connect gateways
VNet peeringVPC peering (non-transitive)Peering does not route through a third VPC; Transit Gateway does
Azure Private DNS zones and DNS Private ResolverRoute 53 private hosted zones and Resolver endpointsInbound endpoint = on-premises asks AWS; outbound endpoint = AWS asks on-premises
Entra Domain ServicesAWS Managed Microsoft ADReal Windows AD, run by AWS; can trust your on-premises forest
Azure ASR network mappingPlanned IPs in launch templates and subnetsAWS does not stretch Layer 2; re-IP or use NAT, plan it per application

Architecture

Security-boundary view. The connection ends in a dedicated transit VPC or Transit Gateway route table, not directly in a workload VPC. Route tables decide which AWS subnets can reach which on-premises ranges, and security groups plus network ACLs enforce it. For regulated flows (card data, for example) keep them in separate route tables and inspect traffic with a firewall (see Network Firewall). VPN tunnels are IPsec-encrypted; if you use Direct Connect, add MACsec or run a VPN over it when policy requires encryption in transit ⚠ VERIFY the available options for your port type. Log everything: VPC Flow Logs, Resolver query logs and VPN tunnel logs go to CloudWatch Logs with retention set.

Step-by-step implementation

Plan addresses

Inventory every range in use: data centres, branch networks, partner links, other clouds, container pools and VPN client pools. Choose AWS ranges that overlap with none of them and leave room to grow. The planner below checks overlaps and RFC 1918 compliance.

Choose transport

NeedChoice
Pilot wave, deadline in weeks, modest dataVPN over two tunnels, BGP
Production waves, steady data, latency-sensitive chatty appsDirect Connect at two locations, with a VPN as backup
Bulk first copy of tens of TBNetwork if time allows; otherwise an offline transfer device ⚠ VERIFY current options

Build the hub

Create a Transit Gateway, attach the VPC(s), the VPN and (later) a Direct Connect gateway. Use separate route tables for production, non-production and regulated segments, and propagate only what each needs.

Wire DNS in both directions

Create a Resolver outbound endpoint with a forwarding rule for the on-premises domain (so AWS workloads resolve harbourline.local through on-premises DNS) and an inbound endpoint (so on-premises DNS can forward aws.harbourline.internal to AWS). Associate the rule with each VPC. Keep one authoritative owner per name: never create the same name in both places.

Extend identity

Decide per application: use AWS Managed Microsoft AD with a trust to on-premises, AD Connector (a proxy to your on-premises domain controllers; requires the link to be up), or move to modern identity (OIDC with Entra ID federated into IAM Identity Center for staff). For a long migration, a Managed AD with a one-way or two-way trust is the stable middle path.

Measure, then place applications

Measure round-trip time and throughput between sites. Move chatty application pairs together; if a web tier moves before its database, front it with caching or batch calls, or delay the move.

Latency rules of thumb

PatternRisk across a hybrid linkMitigation
40 small queries per pageLatency multiplies: 40 x 12 ms = 480 msMove web and data together, or add caching
Large file or batch transferBandwidth, not latencySchedule, compress, use DataSync
Synchronous call chain A to B to C across the linkFailures multiplyAdd timeouts, retries with jitter, circuit breakers
Kerberos and LDAP lookups per requestDomain controller reachabilityKeep a domain controller or Managed AD in AWS

AWS Console instructions

  • VPC → Customer gateways → Create (public IP of your router or firewall; BGP ASN).
  • VPC → Transit gateways → Create, then Transit gateway attachments → Create (VPC and VPN types).
  • VPC → Site-to-Site VPN connections → Create (target: Transit Gateway; routing: dynamic BGP). Download the configuration for your vendor and apply it to the on-premises device.
  • Route 53 → Resolver → Inbound endpoints / Outbound endpoints → Create (two subnets in different AZs, security group allowing UDP and TCP 53), then Rules → Create rule (Forward, domain harbourline.local, target IP of on-premises DNS) and associate it with the VPC.
  • Directory Service → Directories → Set up directory → AWS Managed Microsoft AD, then Networking → Trust relationships → Add (one-way or two-way, forest trust).

AWS CLI

# Create a customer gateway for the on-premises device (203.0.113.10 is a documentation address).
aws ec2 create-customer-gateway --type ipsec.1 --bgp-asn 65010 --public-ip 203.0.113.10 \
  --tag-specifications 'ResourceType=customer-gateway,Tags=[{Key=Project,Value=cea-lab}]' \
  --profile learn-sandbox --region us-east-1

# Create a Site-to-Site VPN connection to a Transit Gateway.
aws ec2 create-vpn-connection --type ipsec.1 --customer-gateway-id cgw-0123456789abcdef0 \
  --transit-gateway-id tgw-0123456789abcdef0 \
  --options TunnelInsideIpVersion=ipv4 \
  --profile learn-sandbox --region us-east-1

# Inspect tunnel state (UP or DOWN) for both tunnels.
aws ec2 describe-vpn-connections --vpn-connection-ids vpn-0123456789abcdef0 \
  --query "VpnConnections[].VgwTelemetry[].{ip:OutsideIpAddress,status:Status,msg:StatusMessage}" \
  --profile learn-sandbox --region us-east-1 --output table

# List Resolver endpoints and rules.
aws route53resolver list-resolver-endpoints --profile learn-sandbox --region us-east-1
aws route53resolver list-resolver-rules --profile learn-sandbox --region us-east-1

The IDs are placeholders. For a Transit Gateway VPN the telemetry fields differ from a virtual private gateway connection ⚠ VERIFY the query against describe-vpn-connections output in your account.

Infrastructure as Code

HybridNetworkStack.cs
using Amazon.CDK;
using Amazon.CDK.AWS.EC2;
using Amazon.CDK.AWS.Route53Resolver;
using Constructs;

namespace Harbourline.Migration.Infra;

public sealed class HybridNetworkStack : Stack
{
    public HybridNetworkStack(Construct scope, string id, IStackProps? props = null)
        : base(scope, id, props)
    {
        var vpc = new Vpc(this, "ProdVpc", new VpcProps
        {
            IpAddresses = IpAddresses.Cidr("10.60.0.0/16"), // no overlap with 10.10.0.0/16 on premises
            MaxAzs = 2,
            NatGateways = 1,
            VpnGateway = true,        // virtual private gateway; use Transit Gateway for many VPCs
            VpnGatewayAsn = 64512,
            VpnRoutePropagation = [new SubnetSelection { SubnetType = SubnetType.PRIVATE_WITH_EGRESS }]
        });

        vpc.AddVpnConnection("DataCentre", new VpnConnectionOptions
        {
            Ip = "203.0.113.10", // documentation address: replace with the real firewall public IP
            Asn = 65010          // BGP
        });

        var dnsSg = new SecurityGroup(this, "ResolverSg", new SecurityGroupProps
        {
            Vpc = vpc,
            Description = "DNS to and from on premises",
            AllowAllOutbound = false
        });
        dnsSg.AddIngressRule(Peer.Ipv4("10.10.0.0/16"), Port.Udp(53), "on-prem DNS");
        dnsSg.AddIngressRule(Peer.Ipv4("10.10.0.0/16"), Port.Tcp(53), "on-prem DNS");
        dnsSg.AddEgressRule(Peer.Ipv4("10.10.0.0/16"), Port.Udp(53), "to on-prem DNS");
        dnsSg.AddEgressRule(Peer.Ipv4("10.10.0.0/16"), Port.Tcp(53), "to on-prem DNS");

        var subnets = vpc.SelectSubnets(new SubnetSelection { SubnetType = SubnetType.PRIVATE_WITH_EGRESS }).SubnetIds;

        _ = new CfnResolverEndpoint(this, "Inbound", new CfnResolverEndpointProps
        {
            Direction = "INBOUND",
            SecurityGroupIds = [dnsSg.SecurityGroupId],
            IpAddresses = subnets.Select(s => new CfnResolverEndpoint.IpAddressRequestProperty { SubnetId = s }).Cast<object>().ToArray()
        });

        var outbound = new CfnResolverEndpoint(this, "Outbound", new CfnResolverEndpointProps
        {
            Direction = "OUTBOUND",
            SecurityGroupIds = [dnsSg.SecurityGroupId],
            IpAddresses = subnets.Select(s => new CfnResolverEndpoint.IpAddressRequestProperty { SubnetId = s }).Cast<object>().ToArray()
        });

        var rule = new CfnResolverRule(this, "ForwardOnPrem", new CfnResolverRuleProps
        {
            DomainName = "harbourline.local",
            RuleType = "FORWARD",
            ResolverEndpointId = outbound.AttrResolverEndpointId,
            TargetIps = new[] { new CfnResolverRule.TargetAddressProperty { Ip = "10.10.0.10", Port = "53" } }
        });

        _ = new CfnResolverRuleAssociation(this, "RuleAssoc", new CfnResolverRuleAssociationProps
        {
            ResolverRuleId = rule.AttrResolverRuleId,
            VpcId = vpc.VpcId
        });

        Amazon.CDK.Tags.Of(this).Add("Project", "cea-lab");
        Amazon.CDK.Tags.Of(this).Add("Lab", "m13-hybrid");
        Amazon.CDK.Tags.Of(this).Add("Environment", "learn");
        Amazon.CDK.Tags.Of(this).Add("Owner", "your-name");
    }
}

⚠ VERIFY the L1 property types for IpAddresses and TargetIps against your CDK version; the inbound endpoint IPs are what the on-premises DNS forwarder targets. A synth-only run costs nothing.

Complete code

A planning tool that does two jobs: verify no CIDR ranges overlap, and estimate how long a replication copy takes. It uses only the base class library.

Program.cs
using System.Net;
using System.Net.Sockets;

// Ranges in use. Replace with your own inventory.
var existing = new Dictionary<string, string>
{
    ["Slough data centre"]   = "10.10.0.0/16",
    ["Branch network"]       = "10.20.0.0/14",
    ["Partner link (Visa)"]  = "172.16.40.0/22",
    ["Employee VPN pool"]    = "10.30.0.0/20"
};
var proposed = new Dictionary<string, string>
{
    ["AWS prod VPC"]         = "10.60.0.0/16",
    ["AWS non-prod VPC"]     = "10.61.0.0/16",
    ["AWS transit"]          = "10.22.0.0/24"   // deliberately wrong: sits inside the branch network
};

var problems = 0;
foreach (var (pName, pCidr) in proposed)
{
    var p = Cidr.Parse(pCidr);
    if (!p.IsPrivate) { Console.WriteLine($"NOT PRIVATE   {pName} {pCidr} is not an RFC 1918 range"); problems++; }
    foreach (var (eName, eCidr) in existing)
        if (p.Overlaps(Cidr.Parse(eCidr))) { Console.WriteLine($"OVERLAP       {pName} {pCidr} overlaps {eName} {eCidr}"); problems++; }
}
foreach (var ((aName, aCidr), (bName, bCidr)) in proposed.SelectMany((a, i) => proposed.Skip(i + 1), (a, b) => (a, b)))
    if (Cidr.Parse(aCidr).Overlaps(Cidr.Parse(bCidr))) { Console.WriteLine($"OVERLAP       {aName} overlaps {bName}"); problems++; }

Console.WriteLine(problems == 0 ? "Address plan is clean." : $"{problems} problem(s) found.");

// Replication time: 10 TB over a 1 Gbps link where 70% is usable for migration.
var hours = Transfer.Hours(terabytes: 10, linkMbps: 1000, usableFraction: 0.7);
Console.WriteLine($"10 TB over 1 Gbps at 70% usable: {hours:F1} hours ({hours / 24:F1} days)");

return problems == 0 ? 0 : 4;

public readonly record struct Cidr(uint Network, int Prefix)
{
    public uint Last => Network | (Prefix == 0 ? uint.MaxValue : ~(uint.MaxValue << (32 - Prefix)));

    public static Cidr Parse(string text)
    {
        var parts = text.Split('/');
        if (parts.Length != 2 || !int.TryParse(parts[1], out var prefix) || prefix is < 0 or > 32)
            throw new FormatException($"Bad CIDR: {text}");
        var ip = IPAddress.Parse(parts[0]);
        if (ip.AddressFamily != AddressFamily.InterNetwork) throw new FormatException("IPv4 only in this tool");
        var bytes = ip.GetAddressBytes();
        var value = (uint)(bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3]);
        var mask = prefix == 0 ? 0 : uint.MaxValue << (32 - prefix);
        return new Cidr(value & mask, prefix); // normalise host bits away
    }

    public bool Overlaps(Cidr other) => Network <= other.Last && other.Network <= Last;

    public bool IsPrivate =>
        Within("10.0.0.0/8") || Within("172.16.0.0/12") || Within("192.168.0.0/16");

    private bool Within(string range)
    {
        var r = Parse(range);
        return Network >= r.Network && Last <= r.Last;
    }
}

public static class Transfer
{
    public static double Hours(double terabytes, double linkMbps, double usableFraction)
    {
        var bits = terabytes * 8d * 1_000_000_000_000d;      // decimal terabytes to bits
        var bitsPerSecond = linkMbps * 1_000_000d * usableFraction;
        return bits / bitsPerSecond / 3600d;
    }
}

Expected output: one OVERLAP line for the transit range, 1 problem(s) found., and about 31.7 hours for the transfer.

Code explained line by line

  1. Cidr.Parse converts the dotted address to a 32-bit unsigned integer and masks off host bits, so 10.22.0.5/24 and 10.22.0.0/24 are the same range.
  2. Last is the highest address in the range: the network value with all host bits set. For /0 the shift would be 32 (undefined in C# for a 32-bit shift), so it is special-cased.
  3. Overlaps is the classic interval test: two ranges overlap when each one starts before the other ends.
  4. IsPrivate requires the range to be wholly inside one RFC 1918 block, not merely to start in it, so 10.0.0.0/7 (which spills into public space) is rejected.
  5. The SelectMany pairs each proposed range with every later proposed range so the AWS ranges are also checked against each other.
  6. Transfer.Hours uses decimal terabytes (10^12 bytes) because that is how storage and networks are sold, and applies a usable fraction: you never get 100% of the link, and production traffic still needs room.
  7. The non-zero exit code lets a pipeline reject a network change that introduces an overlap.

Security considerations

⚠ Learning shortcut — not for production

The lesson uses one VPN connection and a single Transit Gateway for brevity. Production needs redundant customer gateways (two devices, two sites), Direct Connect in two locations (or a VPN backup over a different path), separate Transit Gateway route tables for production, non-production and regulated segments, a firewall inspection point, and tested failover. Test failover by pulling a link in a change window, not in an incident.

  • Least reachable. A hybrid link joins two trust domains. Allow only the ports each application needs between specific ranges; do not allow "any" between data centre and VPC.
  • Segment regulated data. Card-data flows belong in a separate route table and security zone (PCI DSS on AWS). Never claim compliance from the network alone; QSA review is required.
  • DNS is a security control. Enable Resolver query logging, and use Resolver DNS Firewall to block known-bad domains ⚠ VERIFY current feature name and Region support.
  • Active Directory trusts. A trust extends authentication across the boundary. Prefer selective authentication, a one-way trust where possible, and an audited process for who can administer the AWS-side directory.
  • Key management for VPN. Pre-shared keys are secrets: generate strong ones, store them in Secrets Manager, and rotate on the vendor's guidance.

Banking use case

Harbourline builds the hybrid network before wave 1. Address planning finds that the proposed 10.22.0.0/24 transit range sits inside the branch network, so it moves to 10.62.0.0/24. Two Direct Connect circuits at two locations carry production, and a Site-to-Site VPN is the backup. DNS forwards harbourline.local from AWS to on-premises and aws.harbourline.internal from on-premises to AWS. Managed AD in AWS holds a forest trust to the on-premises domain so .NET services running on EC2 Windows keep Kerberos. Measuring shows 11 ms round-trip between sites; the Branch Portal (40 queries per page) is held back until its database moves in the same wave, and the nightly statement batch moves with the ledger to keep chatty traffic inside one site.

Common mistakes

  • Overlapping ranges. Found late, they force re-IPing production servers. Check before building anything.
  • One tunnel. A VPN connection has two tunnels; configure both, and monitor both.
  • Defining the same DNS name in both places. Which answer wins depends on the resolver path. One authoritative owner per name.
  • Moving the web tier before its database without measuring latency.
  • Underestimating Direct Connect lead time. Order early, or use VPN for the first waves.
  • Forgetting asymmetric routing and MTU. VPN overhead reduces usable MTU; large packets with the don't-fragment bit stall silently (path MTU problems).

Troubleshooting

SymptomLikely causeFix
Both VPN tunnels DOWNIKE or pre-shared key mismatch, or wrong peer IPCompare the downloaded config with the device config; check the firewall allows UDP 500 and 4500
Tunnel UP but no trafficMissing routes or security group rulesCheck route propagation, Transit Gateway route table and on-premises routes
On-premises cannot resolve AWS namesInbound endpoint not reachable or no conditional forwarderPoint the on-premises DNS forwarder at both inbound endpoint IPs; allow UDP and TCP 53
AWS cannot resolve on-premises namesRule not associated with the VPCAssociate the forwarding rule with the VPC; check outbound endpoint security group
Large transfers hang while pings workMTU or fragmentationLower MTU or enable MSS clamping on the device
Kerberos failuresTime skew or blocked ports to domain controllersFix time sync; allow Kerberos and LDAP ports to the controllers

Cost and cleanup

Cost: paid. A Site-to-Site VPN connection costs a small hourly fee plus data transfer (on the order of USD 0.05 per hour ⚠ VERIFY), a Transit Gateway attachment costs per hour and per GB, and each Resolver endpoint costs per ENI per hour (two ENIs minimum per endpoint ⚠ VERIFY). Direct Connect charges port-hours and data transfer out, and Managed AD charges per hour. A one-hour experiment is a few dollars; leaving it overnight is not. Free alternative: run the planner and cdk synth or terraform validate and plan only.

# Delete in reverse order: rule association, rule, endpoints, VPN, attachment, gateway.
aws route53resolver disassociate-resolver-rule --vpc-id vpc-0123456789abcdef0 --resolver-rule-id rslvr-rr-0123456789abcdef0 --profile learn-sandbox
aws route53resolver delete-resolver-rule --resolver-rule-id rslvr-rr-0123456789abcdef0 --profile learn-sandbox
aws route53resolver delete-resolver-endpoint --resolver-endpoint-id rslvr-in-0123456789abcdef0 --profile learn-sandbox
aws route53resolver delete-resolver-endpoint --resolver-endpoint-id rslvr-out-0123456789abcdef0 --profile learn-sandbox
aws ec2 delete-vpn-connection --vpn-connection-id vpn-0123456789abcdef0 --profile learn-sandbox
aws ec2 delete-customer-gateway --customer-gateway-id cgw-0123456789abcdef0 --profile learn-sandbox

# Or: cdk destroy / terraform destroy. Then confirm nothing tagged Project=cea-lab remains.
aws resourcegroupstaggingapi get-resources --tag-filters Key=Project,Values=cea-lab --profile learn-sandbox

Exercises

  • 🟢 Guided: Run the planner, fix the overlap by choosing a safe transit range, and re-run until it prints "Address plan is clean." Then change the link to 10 Gbps and note the new transfer time.
  • 🟡 Challenge: Add a check that every proposed range is at least a /24 and no larger than a /16, and a function that suggests the first free /16 between 10.40.0.0 and 10.99.255.255 that overlaps nothing.
  • 🔴 Live problem: After wave 1 the Branch Portal in AWS takes 6 seconds per page instead of 1. Traffic shows 40 queries to a SQL Server still on premises, at 11 ms each. List your options (move the database, add a read replica or cache in AWS, batch the calls, adjust the wave plan), and recommend one with the evidence you would show the product owner.

Assignment

Produce hybrid-network-design.md: address plan with a table of all ranges, transport choice with redundancy diagram, DNS design with names and owners, identity approach, latency analysis for the three busiest applications, and a failover test plan.

Solutions

Knowledge check

Interview questions

  • How do you keep applications working while they straddle two sites? Address plan, redundant connectivity, DNS in both directions, shared identity, measured latency and moving chatty pairs together.
  • A VPN tunnel flaps at month end. What do you check? Both tunnel states, BGP session and route advertisements, device logs and CPU, MTU and the traffic pattern at that time, then fail over to the second tunnel or Direct Connect.
  • Why avoid stretching a Layer 2 network into AWS? It extends failure domains and broadcast behaviour, and AWS does not support it as a design pattern; re-IP or use NAT per application.

Certification practice

Completion checklist

  • I can explain the four things a hybrid network needs
  • I ran the planner and fixed an overlap
  • I can describe the inbound and outbound Resolver endpoints
  • I can estimate a replication time and justify the usable fraction
  • I ran the cleanup steps (or did the design-only path) and confirmed nothing is billing

Key takeaways

  • Plan addresses first; overlaps are the most expensive mistake to fix later.
  • VPN for speed, Direct Connect for steady production, both for resilience.
  • DNS needs both directions, with one authoritative owner per name.
  • Chatty applications must move together or be measured first.
  • Identity (Managed AD with a trust) is part of the network design.

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