Skip to Content
Cloud Engineering Academy
14. Advanced Banking Architecture

Secure external integrations

Design safe connections to partner APIs, webhooks and file exchanges using egress allow-lists, mutual TLS, signed webhooks and third-party risk controls, and verify signed webhooks with a runnable C# verifier.

advanced⏱ 2 h 30 min🟢 FreeSAP-C03SAA-C03SCS-C03

Assumes: .NET 10 LTS (file-based apps) · AWS SDK for .NET v4 · Amazon.CDK.Lib 2.277.0 · 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:

  • Classify an external integration by direction (outbound, inbound, file) and by what happens to the bank if it fails or is compromised.
  • Design controlled egress from private subnets using an allow-list firewall, and decide when PrivateLink is better.
  • Choose between API keys, OAuth client credentials and mutual TLS for partner authentication, and say where the certificates live.
  • Verify an inbound webhook with an HMAC signature, a timestamp window, secret rotation and replay protection.
  • Describe the third-party-risk controls a design authority expects: due diligence, concentration, exit plan, monitoring and incident contacts.
  • Apply the 15-section template to a partner integration and mark every regulatory point as needing review.

Prerequisites

Why this matters in banking

Harbourline's payment flow calls a sanctions-screening provider, a card processor and an identity-verification vendor, and receives webhooks from the settlement partner. Each connection is a door in the bank's wall. When one fails the bank may not be able to move money. When one is compromised the bank may leak customer data or accept forged payment confirmations.

Three real-world patterns cause most incidents:

  1. Open egress. A compromised container can send data to any address on the internet because the NAT gateway allows everything.
  2. Unverified webhooks. An endpoint accepts payment.settled from anyone who guesses the URL.
  3. Single dependency with no plan. The screening provider has an outage and nobody decided whether payments are held or released.

Educational content, not legal or regulatory advice

Outsourcing and third-party rules differ by jurisdiction and regulator (for example operational-resilience and ICT third-party regimes in the UK and EU) ⚠ VERIFY which apply to Harbourline-like firms. This lesson gives engineering controls and the questions to ask. Your risk, procurement, legal and compliance functions decide what is required.

The idea in plain language

Treat every external party as untrusted by default and critical by dependency. Both are true at once: you must defend against them and depend on them.

DirectionExampleMain risksMain controls
Outbound APICall screening providerData leakage, SSRF, provider outageEgress allow-list, mTLS or OAuth, timeouts, circuit breaker, minimal data
Inbound webhookSettlement confirmationForgery, replay, floodingSignature, timestamp, idempotency, throttling, WAF
Inbound APIOpen Banking TPP callsOver-broad access, abuseOAuth scopes, mTLS, consent checks, rate limits
File exchangeStatements over SFTPTampering, malware, duplicatesPer-partner identity, hash check, quarantine (reconciliation)

Analogy: a bank's cash-in-transit arrangement. The armoured van company is a vital supplier, but the vault door only opens for named, verified crew at agreed times, every handover is signed, and there is a plan if the van company fails to turn up.

What problem the AWS services solve

NeedAWS optionLimits and sharp edges
Control outbound destinationsAWS Network Firewall with a domain allow-list (TLS SNI and HTTP host), behind a NAT gatewayDomain rules rely on SNI/Host, so they cannot see inside TLS; hourly endpoint cost ⚠ VERIFY
Private provider connectivityAWS PrivateLink (endpoint to a provider's endpoint service)The provider must offer it; you then avoid the internet path entirely
Inbound mTLSAPI Gateway custom domain with a truststore in S3Needs a custom domain, and you disable the default execute-api endpoint so clients cannot bypass mTLS ⚠ VERIFY current setup
Outbound client certificatesAWS Secrets Manager or ACM Private CA for your own CAPublic ACM certificates do not export private keys; plan certificate issuance
Outbound webhooksEventBridge API destinations with connectionsBuilt-in rate limiting and retries; a destination invocation has a short timeout ⚠ VERIFY limits
Edge defenceAWS WAF, ShieldRules need tuning to avoid blocking legitimate partners
Secret storage and rotationSecrets ManagerRotation needs a rotation function and a partner that accepts overlapping secrets

Microsoft / Azure comparison

You know (Microsoft/Azure)AWS equivalentWhat's different
Azure Firewall FQDN rulesNetwork Firewall domain listsSame idea; you route traffic through firewall endpoints with route tables
Private Endpoint to partner servicePrivateLinkProvider-initiated endpoint service, consumer creates an interface endpoint
API Management client certificate validationAPI Gateway mTLS truststoreTruststore is a PEM bundle in S3
Key Vault certificatesSecrets Manager, ACM Private CACertificates and secrets are separate services
Event Grid webhooks with validation handshakeEventBridge API destinations; your own verifier for inboundInbound signature checking is code you own

Architecture

Security-boundary view

Every arrow that crosses a boundary has an authentication mechanism and a log line. Inbound data is verified before it touches the application zone.

The 15-section design

The fictional integration: Harbourline's payment service calls an external sanctions-screening provider (outbound), and receives settlement webhooks from a scheme partner (inbound).

Sections 1 to 3: requirements

SectionContent
1 BusinessScreen every payment before release; accept settlement confirmations reliably; remain able to explain every external call to regulators and to the board's risk committee
2 FunctionalF1 Call screening with a decision and reference. F2 Hold payments if screening cannot complete. F3 Accept only authentic, fresh, unique webhooks. F4 Rotate partner secrets without downtime. F5 Alert on partner failure. F6 Keep a record of every external call and verdict
3 Non-functionalScreening call p99 under 1.5 s with 2 s timeout and 3 bounded retries. Webhook verification under 50 ms. 99.9% availability of the webhook endpoint. No outbound traffic to unlisted domains. Secret rotation every 90 days ⚠ VERIFY policy. Webhook replay window 5 minutes

Section 5: service selection

ChoiceWhyRejected alternativeTrade-off
Network Firewall allow-listCentral, auditable egress controlOpen NAT gateway with security groups onlyCost and routing complexity
mTLS plus OAuth for screeningStrong client identity plus scoped tokensAPI key aloneCertificate lifecycle to manage
HMAC signature on webhooksSimple, partner-supportedIP allow-list onlyNeeds shared-secret rotation; IPs can change
SQS buffer after verificationAbsorbs bursts, decouples from partner timingDirect synchronous processingSlight delay in processing
Fail closed on screening outageNever release unscreened paymentsFail openCustomers see "pending" during outages

Sections 6 and 7: network and security

  • Network. Application subnets route 0.0.0.0/0 to firewall endpoints, then to NAT. Firewall rules allow only named domains (for example .screening-provider.example.com) and drop everything else, logging drops. Use VPC endpoints for AWS services so that traffic never uses the firewall path.
  • Identity. Screening client certificate in Secrets Manager, readable only by the payments task role. Webhook secrets likewise. Two secrets are valid at once during rotation.
  • Data minimisation. Send the screening provider only what it needs: name, country, date of birth where required, payment amount and currency. Never send account numbers or free-text notes unless the contract requires it ⚠ VERIFY with the data-protection officer, and record the legal basis and processor terms.
  • Logging. Log provider name, endpoint, status, latency and correlation ID. Do not log request bodies containing personal data.
  • Threat model (STRIDE highlights). Spoofing: forged webhook. Tampering: modified body. Repudiation: partner denies sending; keep signed payloads. Information disclosure: egress to attacker domain. Denial of service: webhook flood or provider slowness. Elevation: webhook triggers privileged action without checks.

Sections 8 to 10: API, data and flow

  • API (inbound). POST /partner/settlements with headers X-Timestamp, X-Signature: v1=<hex>, X-Event-Id. Always respond fast (accept or reject) and do the work from the queue. Return 2xx only after the event is durably queued; partners retry on non-2xx.
  • Database. DynamoDB table webhook_events keyed by eventId, with TTL longer than the partner's retry window, written with a condition attribute_not_exists(eventId).
  • Data flow. (1) Partner sends. (2) WAF filters. (3) Verifier checks timestamp, signature and replay. (4) Event is queued. (5) Consumer updates payment status idempotently. (6) Audit event written.

Section 11: failure scenarios

FailureDetectionAutomatic responseImpactManual step
Screening provider slowTimeout at 2 sBounded retry then hold payment as screeningPayment pendingOperations clear queue after recovery
Provider hard downCircuit breaker opensPayments held; alarmPending paymentsBusiness decision on second provider
Certificate expiryExpiry alarm at 30 and 7 daysNone if rotated earlyCalls fail if missedRotate certificate
Forged webhookSignature mismatchReject 401, count metricNoneInvestigate source
Replay of old webhookDuplicate eventId or stale timestampReject or ignoreNoneNone
Webhook floodWAF rate rule, API throttleThrottle and shedPossible delaysReview rules
Partner secret leakedPartner notice or anomalyRotate secret; previous secret is revoked after cut-overBrief risk windowIncident process
Egress to unlisted domainFirewall drop logBlock and alertNoneInvestigate compromised workload

Sections 12 to 15

  • Scalability. The verifier is stateless; the replay cache scales with DynamoDB. The first quota to check is API Gateway throttling, then Lambda concurrency ⚠ VERIFY current limits. Partner rate limits cap outbound throughput; queue and pace calls.
  • Cost. Network Firewall endpoint hours and per-GB processing usually dominate; NAT gateway and data transfer follow. Estimate per-AZ endpoint count and GB per month ⚠ VERIFY prices. Reduce cost with VPC endpoints for AWS traffic.
  • Implementation. Phase 1 egress allow-list in a non-production account. Phase 2 verifier with replay cache. Phase 3 secret rotation rehearsal. Phase 4 circuit breaker and fail-closed behaviour. Phase 5 game day: provider down, certificate expired, webhook flood.
  • Compliance touchpoints.
AreaWhere it touchesReviewing teamEvidence
Third-party and outsourcing risk ⚠ VERIFYProvider onboarding, exit planThird-party risk, procurementDue-diligence file, exit plan
Sanctions screening obligations ⚠ VERIFYHold policy, retries, record keepingFinancial-crime complianceSigned hold policy, call records
Data protection (processor, transfers)Fields sent, location of providerData protection officerData-processing agreement, transfer assessment
Operational resilienceImpact tolerance of paymentsOperational resilience leadScenario test results
Security architecturemTLS, egress, secretsSecurity architectureControl mapping

Step-by-step implementation

Inventory every external call

List each provider, direction, data sent, authentication, timeout and owner. A call nobody can name is a finding.

Create the egress allow-list

Start in monitor mode: log all outbound domains for a week, review them with application owners, then enforce. Add domains by pull request.

Implement and test the webhook verifier

Verify the timestamp first (cheap), then the signature with a constant-time compare, then the replay cache. Test with tampered bodies, old timestamps and garbage signatures.

Plan secret rotation

Accept two secrets during rotation: the new and the previous. Rotate, watch metrics for traffic still using the old secret, then remove it.

Add timeouts, bounded retries and a circuit breaker

Set a call timeout below the caller's own deadline, retry only idempotent calls, and open the breaker after repeated failures so the bank stops hammering a failing provider (resilience patterns).

Write the exit plan

Document how to switch provider, what data must be exported, how long it takes, and who decides. Revisit yearly.

AWS Console instructions

  • Console → VPC → Network Firewall → Firewall policies / Rule groups → Create rule group. Choose Stateful, Domain list, action Allow, add domains such as .screening-provider.example.com.
  • Console → VPC → Network Firewall → Firewalls → Create firewall, select the VPC and one firewall subnet per Availability Zone, attach the policy, enable logging to CloudWatch Logs or S3.
  • Console → API Gateway → Custom domain names → Create, enable Mutual TLS and give the S3 truststore URI. Then disable the default endpoint on the API.
  • Console → Secrets Manager → Store a new secret for the webhook secret; enable rotation only when a rotation function exists.

AWS CLI

# List firewalls (read-only) to confirm what exists before designing changes.
aws network-firewall list-firewalls --profile learn-sandbox --region us-east-1

# Create a secret for the webhook signing key (fictional value; a real one is generated, never typed).
aws secretsmanager create-secret --name hl-m14/partner-webhook-secret \
  --secret-string "$(openssl rand -hex 32)" \
  --tags Key=Project,Value=cea-lab Key=Lab,Value=m14-l11 Key=Environment,Value=learn Key=Owner,Value=learner \
  --profile learn-sandbox --region us-east-1

# Enable mutual TLS on an API Gateway custom domain (truststore is a PEM bundle in S3).
aws apigateway create-domain-name --domain-name api.harbourline.example \
  --regional-certificate-arn <acm-certificate-arn> \
  --endpoint-configuration types=REGIONAL \
  --mutual-tls-authentication truststoreUri=s3://hl-m14-truststore/truststore.pem \
  --profile learn-sandbox --region us-east-1

The last command is design-only in the sandbox: it needs a domain you own and an ACM certificate. Check flags with aws apigateway create-domain-name help ⚠ VERIFY.

Infrastructure as Code

ExternalIntegrationStack.cs
using Amazon.CDK;
using Amazon.CDK.AWS.NetworkFirewall;
using Amazon.CDK.AWS.SecretsManager;
using Constructs;

namespace Harbourline.Architecture.ExternalIntegrations;

public class ExternalIntegrationStack : Stack
{
    public ExternalIntegrationStack(Construct scope, string id, IStackProps? props = null) : base(scope, id, props)
    {
        // Egress allow-list: only the screening provider's domains may be reached over TLS or HTTP.
        new CfnRuleGroup(this, "EgressAllowList", new CfnRuleGroupProps
        {
            RuleGroupName = "hl-m14-egress-allow",
            Type = "STATEFUL",
            Capacity = 100,
            RuleGroup = new CfnRuleGroup.RuleGroupProperty
            {
                RulesSource = new CfnRuleGroup.RulesSourceProperty
                {
                    RulesSourceList = new CfnRuleGroup.RulesSourceListProperty
                    {
                        GeneratedRulesType = "ALLOWLIST",
                        TargetTypes = ["TLS_SNI", "HTTP_HOST"],
                        Targets = [".screening-provider.example.com"],
                    },
                },
            },
        });

        // Webhook signing secret: generated, never typed. Rotation needs a rotation function (not shown).
        new Secret(this, "WebhookSecret", new SecretProps
        {
            SecretName = "hl-m14/partner-webhook-secret",
            GenerateSecretString = new SecretStringGenerator
            {
                PasswordLength = 48,
                ExcludePunctuation = true,
            },
        });

        Amazon.CDK.Tags.Of(this).Add("Project", "cea-lab");
        Amazon.CDK.Tags.Of(this).Add("Lab", "m14-l11");
        Amazon.CDK.Tags.Of(this).Add("Environment", "learn");
        Amazon.CDK.Tags.Of(this).Add("Owner", "learner");
    }
}

The rule group alone does nothing: a firewall policy, a firewall in dedicated subnets and route-table changes complete the path. Treat this as the policy fragment of a larger design.

Complete code

The verifier below accepts a webhook only if its timestamp is fresh, its HMAC matches one of the active secrets (current or previous), and the event ID has not been seen. It runs locally with no AWS dependency.

WebhookVerifier.cs
// Run with: dotnet run WebhookVerifier.cs
// Verifies signed webhooks: HMAC-SHA256 over "timestamp.body", a freshness window,
// secret rotation (two active secrets) and replay rejection.
using System.Security.Cryptography;
using System.Text;

var current = "demo-secret-2026-11-not-real"u8.ToArray();
var previous = "demo-secret-2026-10-not-real"u8.ToArray();
var now = DateTimeOffset.Parse("2026-11-18T10:00:00Z");
var verifier = new WebhookVerifier([current, previous], TimeSpan.FromMinutes(5), () => now);

var body = """{"eventId":"evt-001","type":"payment.settled","paymentId":"PAY-0001"}""";
var ts = now.AddSeconds(-30).ToUnixTimeSeconds().ToString();

Check("valid, current secret", verifier.Verify(ts, WebhookVerifier.Sign(current, ts, body), "evt-001", body));
Check("replay of same event ", verifier.Verify(ts, WebhookVerifier.Sign(current, ts, body), "evt-001", body));
Check("valid, old secret    ", verifier.Verify(ts, WebhookVerifier.Sign(previous, ts, body), "evt-002", body));
Check("tampered body        ", verifier.Verify(ts, WebhookVerifier.Sign(current, ts, body), "evt-003", body + " "));
var old = now.AddMinutes(-20).ToUnixTimeSeconds().ToString();
Check("stale timestamp      ", verifier.Verify(old, WebhookVerifier.Sign(current, old, body), "evt-004", body));
Check("garbage signature    ", verifier.Verify(ts, "v1=zzzz", "evt-005", body));
return 0;

static void Check(string label, Verdict v) => Console.WriteLine($"{label} -> {v}");

public enum Verdict { Accepted, BadSignature, Stale, Replay, Malformed }

public sealed class WebhookVerifier(IReadOnlyList<byte[]> secrets, TimeSpan tolerance, Func<DateTimeOffset> clock)
{
    // In production this is a DynamoDB conditional put with a TTL, not process memory.
    private readonly HashSet<string> _seen = [];

    public static string Sign(byte[] secret, string timestamp, string body)
    {
        var mac = HMACSHA256.HashData(secret, Encoding.UTF8.GetBytes($"{timestamp}.{body}"));
        return "v1=" + Convert.ToHexString(mac).ToLowerInvariant();
    }

    public Verdict Verify(string timestamp, string signatureHeader, string eventId, string body)
    {
        if (!long.TryParse(timestamp, out var seconds)) return Verdict.Malformed;
        var age = clock() - DateTimeOffset.FromUnixTimeSeconds(seconds);
        if (age > tolerance || age < -tolerance) return Verdict.Stale;

        if (!signatureHeader.StartsWith("v1=", StringComparison.Ordinal)) return Verdict.Malformed;
        byte[] provided;
        try { provided = Convert.FromHexString(signatureHeader[3..]); }
        catch (FormatException) { return Verdict.BadSignature; }

        var ok = false;
        foreach (var secret in secrets)
        {
            var expected = HMACSHA256.HashData(secret, Encoding.UTF8.GetBytes($"{timestamp}.{body}"));
            ok |= CryptographicOperations.FixedTimeEquals(expected, provided);   // no early exit
        }
        if (!ok) return Verdict.BadSignature;

        return _seen.Add(eventId) ? Verdict.Accepted : Verdict.Replay;
    }
}

Expected output:

valid, current secret -> Accepted
replay of same event  -> Replay
valid, old secret     -> Accepted
tampered body         -> BadSignature
stale timestamp       -> Stale
garbage signature     -> BadSignature

The demo secrets are obviously fake. In production the secrets come from Secrets Manager at startup and are refreshed on a schedule.

Code explained line by line

  1. The primary constructor WebhookVerifier(IReadOnlyList<byte[]> secrets, TimeSpan tolerance, Func<DateTimeOffset> clock) injects the clock, so tests can freeze time instead of waiting.
  2. Sign computes HMAC-SHA256 over "{timestamp}.{body}". Binding the timestamp into the signed text stops an attacker reusing an old body with a new timestamp.
  3. Verify checks the timestamp first, because it is cheap and rejects obviously stale traffic before any cryptography.
  4. A signature that is not valid hex raises FormatException from Convert.FromHexString. Catching it returns BadSignature rather than crashing the endpoint with a 500.
  5. CryptographicOperations.FixedTimeEquals compares in constant time, so an attacker cannot learn the signature one byte at a time from response timing.
  6. The loop over secrets ORs results without an early exit, so which secret matched is not observable from timing. This supports rotation: the partner switches to the new secret whenever ready.
  7. The replay check runs last, only after a valid signature, so unauthenticated callers cannot fill the replay cache with junk IDs.
  8. _seen is process memory for the demo. Across Lambda instances or containers you need a shared store: a DynamoDB conditional put with TTL.

Security considerations

⚠ Learning shortcut — not for production

The verifier keeps seen event IDs in memory and the lab embeds demo secrets in source. Production loads secrets from Secrets Manager, stores replay IDs in a shared table with TTL, logs rejected requests with a correlation ID (never the secret), and alerts on a spike in BadSignature.

  • Verify the raw bytes. Compute the HMAC over the exact body bytes received. Parsing and re-serialising JSON changes whitespace and breaks signatures.
  • Do not trust IP allow-lists alone. They help as a second layer but providers change addresses.
  • Bound everything. Maximum body size, request rate and processing time. Reject early.
  • SSRF. If your service fetches URLs supplied by partners, validate against an allow-list and block link-local metadata addresses.
  • Certificates. Alarm on expiry at 30 and 7 days; keep private keys out of container images (secrets management).
  • Logging. Record who called, what was decided and why. Do not log full bodies with personal data.

Banking use case

Harbourline's screening provider has a planned maintenance window that overruns by 40 minutes. Payments continue to arrive. The circuit breaker opens after repeated timeouts; new payments enter screening status and are held, not released. The customer app shows "processing". A dashboard shows the held count and age. When the provider returns, a controlled drain re-screens held payments in order at a paced rate. The post-incident review checks the held-payment SLA against the bank's impact tolerance for payment initiation ⚠ VERIFY, and decides whether a second provider is justified. The ADR from lesson 1 records "fail closed" as the decision.

Common mistakes

  • Using == to compare signatures. It leaks timing. Use a constant-time compare.
  • Skipping the timestamp. A captured valid request can then be replayed forever.
  • Replying 200 before queuing. A crash loses the event and the partner will not retry.
  • Retrying non-idempotent calls blindly. Provider calls may need idempotency keys.
  • Allow-listing * domains "temporarily". Temporary rules become permanent.
  • No exit plan. Concentration risk becomes visible only during an outage.

Troubleshooting

SymptomLikely causeFix
Legitimate webhooks rejected as BadSignatureBody re-serialised before verification, or wrong secretVerify raw bytes; check the active secrets list
Webhooks rejected as StaleServer clock drift or tolerance too smallFix time sync (use Amazon Time Sync Service); widen tolerance modestly
Outbound call times out after firewall deploymentDomain not in allow-list or missing routeCheck firewall drop logs; confirm route table sends traffic via the firewall
x509: certificate has expiredClient certificate lapsedRotate; add expiry alarms
mTLS clients get 403Client certificate not chained to truststoreAdd the issuing CA to the truststore and wait for propagation
Replay cache grows without boundNo TTLSet TTL beyond the partner retry window

Cost and cleanup

The C# verifier is free. Network Firewall endpoints bill hourly while they exist (and per GB processed) ⚠ VERIFY, so this lesson treats the firewall as design-only in the sandbox. If you deploy only the rule group and the secret, cost is a secret (a small monthly fee) and nothing for an unattached rule group.

# Delete the secret immediately (skip the default recovery window in the sandbox only).
aws secretsmanager delete-secret --secret-id hl-m14/partner-webhook-secret \
  --force-delete-without-recovery --profile learn-sandbox --region us-east-1

# CDK or Terraform teardown.
cdk destroy --profile learn-sandbox
terraform destroy

# Confirm nothing tagged for the course remains.
aws resourcegroupstaggingapi get-resources --tag-filters Key=Project,Values=cea-lab \
  --profile learn-sandbox --region us-east-1

Exercises

  • 🟢 Guided: run the verifier and change the tolerance to 10 seconds. Predict which lines of output change.
  • 🟡 Challenge: add a maxBodyBytes check that returns a new TooLarge verdict, and justify the limit you chose.
  • 🔴 Live problem: the settlement partner says they rotated their webhook secret yesterday without telling you, and 30 percent of events are now rejected. Describe your immediate mitigation, the root-cause fix, and the contract clause you would ask procurement to add.

Assignment

Add architecture/external-integrations/ to your portfolio: an inventory table of every external call in a design of your choice, the 15-section document for one integration, a STRIDE table, a rotation runbook and the verifier with unit tests.

Solutions

Knowledge check

Interview questions

  • How do you secure a webhook endpoint? Signature over raw body and timestamp, constant-time compare, freshness window, replay store, throttling and WAF, 2xx only after durable queueing.
  • How do you control what a workload can call out to? Private subnets, a firewall allow-list by domain, VPC endpoints for AWS services, and drop-logging with alerts.
  • What belongs in an exit plan? Alternative providers, data export format and time, contractual notice and transition support, decision owner and test cadence.
  • mTLS or API keys? mTLS ties calls to a certificate identity and resists key leakage in logs, at the price of certificate lifecycle management. Often combined with OAuth.
  • What do you log for external calls? Destination, outcome, latency, correlation ID and decision, but not personal data payloads.

Certification practice

Completion checklist

  • I can classify an integration by direction and failure impact
  • I ran the verifier and understand every verdict
  • I designed egress allow-listing and secret rotation
  • I wrote the failure table with provider outage and forged webhook rows
  • I ran the cleanup steps and confirmed nothing tagged Project=cea-lab remains

Key takeaways

  • External parties are both untrusted and critical: authenticate, limit and plan for failure.
  • Allow-list egress; prefer PrivateLink where offered.
  • Verify webhooks by timestamp, constant-time HMAC and replay protection; return 2xx only after queuing.
  • Support overlapping secrets so rotation causes no outage.
  • Third-party risk, data-protection and regulatory points need specialist review.

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