Skip to Content
Cloud Engineering Academy
11. Monitoring, Logging & Troubleshooting

CloudWatch metrics and custom business metrics with the Embedded Metric Format

Understand namespaces, dimensions, units, statistics and resolution, publish a business metric (failed transfers per minute) from C# as an Embedded Metric Format log line, and price the result before you deploy it.

intermediate⏱ 1 h 30 min🟡 Low costSOA-C03DOP-C02DVA-C03

Assumes: .NET 10 LTS · AWSSDK.CloudWatch 4.1.1.2 · Embedded Metric Format specification (checked 2026-11-18) · AWS CLI v2 · Region us-east-1. Verified against official sources on 2026-11-18.

Learning objectives

By the end of this lesson you can:

  • Describe a CloudWatch metric by its namespace, name, dimensions, unit, statistic and period, and explain what a data point is.
  • Choose between PutMetricData, the Embedded Metric Format (EMF) and OpenTelemetry metrics for a custom business metric.
  • Write a valid EMF document from C# (the lab's EmfWriter), including multiple dimension sets, and explain the limits the specification imposes.
  • Predict how many custom metrics (and how much money) a design creates, and spot a dimension that will explode the bill.
  • Read a metric back with the CLI and the .NET SDK.

Prerequisites

Why this matters in banking

A bank's service-level questions are business questions: "How many transfers failed in the last five minutes?", "Is the payment p99 above our promise?" AWS publishes technical metrics for you (CPU, request count, queue depth), but not "transfers by outcome". If the only way to know the failed-transfer rate is to scan logs, your alarm is slow and expensive. If you instead publish a business metric at the moment each transfer completes, the alarm is cheap, fast and precise.

The danger is the other direction. A well-meaning engineer adds customerId as a dimension "so we can see per-customer error rates". CloudWatch creates one metric per distinct value, a million customers become a million custom metrics, and the next invoice is a surprise. Knowing how metrics are identified and priced is what separates a useful metric from a costly one.

The idea in plain language

A metric is a time-ordered series of numbers. Each number is a data point. CloudWatch identifies one metric by:

PartMeaningExample
NamespaceA container that keeps your metrics apart from AWS's (AWS/... is reserved)Harbourline/Payments
Metric nameWhat is measuredTransferCount
DimensionsUp to 30 name/value pairs that identify which seriesService=transfers-api, Environment=learn, Outcome=failed

Two metrics with the same name but different dimension values are different metrics. A metric with dimensions {Service} and the same metric with {Service, Outcome} are also different metrics, and you only get data in the combinations you published.

Other properties:

  • Unit (Count, Milliseconds, Bytes, Percent, None, and others): documentation and display only; CloudWatch does not convert between them, but an alarm or graph can filter by unit.
  • Statistic: how data points in one period are combined: Sum, Average, Minimum, Maximum, SampleCount, and percentiles such as p99. For a counter like TransferCount you want Sum; for latency you want p95/p99 (and Average only as a trend).
  • Period: the aggregation window, in seconds (multiples of 60 for standard metrics).
  • Resolution: standard (one data point per minute) or high resolution (down to one second, billed higher ⚠ VERIFY). Use high resolution only when you genuinely need sub-minute detection, such as fast-moving payment rails.

CloudWatch keeps metric data for a long time but at decreasing resolution: one-minute data for about 15 days, five-minute data for about 63 days and one-hour data for about 15 months ⚠ VERIFY the exact periods on the CloudWatch concepts page. Sub-minute data is kept for a short period only (a few hours ⚠ VERIFY).

Analogy: A metric is a line on the wall chart in the branch manager's office: "customers waiting" measured every minute. The namespace is which chart book it lives in, the dimensions say which branch and which counter, and the statistic says whether you are plotting the total, the busiest moment, or the slowest 1%. Adding a dimension per customer would be like keeping one wall chart per customer.

Three ways to publish a custom metric

MethodHow it worksGood forWatch out for
PutMetricData APIYour code calls CloudWatch with data pointsBatch jobs, scripts, low-volume metricsAn API call (latency, IAM permission, request charge ⚠ VERIFY) in your code path; lost on crash
Embedded Metric Format (EMF)You write a JSON log line with a metadata block; CloudWatch Logs extracts the metricsHigh-volume app metrics from ECS, Lambda, EC2Needs a Standard-class log group ⚠ VERIFY; log ingestion is billed as well as the metric
OpenTelemetry metrics (OTLP)The OTel SDK exports metrics to a collector or CloudWatch's OTLP endpointOne instrumentation standard across signalsNewer path; check the current availability, pricing and PromQL-based querying before choosing ⚠ VERIFY

This lesson focuses on EMF because it needs no extra permissions or calls: the line is written to stdout like any log, and CloudWatch does the rest.

What problem the AWS service solves

CloudWatch metrics give you cheap, fast, aggregated numbers you can graph and alarm on. Service-published metrics are free (or included) for most AWS services; custom metrics are billed.

Prices checked on the CloudWatch pricing page on 2026-11-18 (US East N. Virginia examples; prices vary by Region ⚠ VERIFY before budgeting):

ItemPrice
Custom metrics, first 10,000USD 0.30 per metric per month
Custom metrics, next 240,000USD 0.10 per metric per month
Free tier10 custom metrics and 1 million API requests per month
Standard alarmUSD 0.10 per alarm metric per month
Log ingestion (Standard class)USD 0.50 per GB

The EMF specification's rules (checked on 2026-11-18). These explain most "my metric didn't appear" problems:

  • The log event must be a single valid JSON object, with nothing before or after it, and an event is limited to the standard log-event size (the specification says 1 MB).
  • The _aws object carries a Timestamp (milliseconds since the Unix epoch) and a CloudWatchMetrics array of metric directives. The timestamp must be no more than 14 days in the past and no more than 2 hours in the future; otherwise CloudWatch silently does not publish the metric.
  • Each directive has a Namespace (1 to 255 printable ASCII characters), Dimensions (an array of dimension sets) and Metrics.
  • A dimension set holds at most 30 keys, and may be empty. Every dimension set creates its own metric; the spec warns that unintentional high-cardinality dimensions such as a request ID will create a metric for every value.
  • A log event holds at most 100 metric definitions in total across directives, and a metric value array at most 100 members.
  • A metric definition has a Name, an optional Unit (default None) and an optional StorageResolution of 1 (high) or 60 (standard, the default).
  • Metric values and dimension values live at the root of the JSON; they cannot be nested objects.
  • Delivery is at least once, so a duplicate data point can occasionally occur: do not build billing-grade counts on it.
  • Failures of EMF processing are reported as metrics in the AWS/Logs namespace of your account, so you can alarm on "EMF stopped working".

Microsoft / Azure comparison

You know (Microsoft/Azure)AWS equivalentWhat's different
TelemetryClient.GetMetric("Transfers").TrackValue(1)An EMF line (or PutMetricData)No client object: write a JSON line; no SDK call in the request path
Custom metrics with dimensions (Azure Monitor custom metrics)CloudWatch custom metrics with dimensionsEach dimension combination is a separately billed metric
Metric namespaces such as Microsoft.Web/sitesNamespaces AWS/ApplicationELB for AWS, your own Harbourline/PaymentsPick a company-wide convention early; namespaces cannot be renamed
Log-based metrics in Application InsightsMetric filters (pattern on a log group) or EMFMetric filters count matching lines; EMF carries the value in the line
Aggregation types (Avg, Min, Max, Sum, Count)Statistics (Average, Minimum, Maximum, Sum, SampleCount, percentiles)Percentiles are first-class statistics
Dimension limits per metricUp to 30 dimensions per metricThe limit that matters is cost, not the count

Architecture

Security-boundary view. The application needs no CloudWatch permission to publish EMF metrics, because it only writes to stdout; the log pipeline's role does the rest. That is a real security advantage over PutMetricData, which needs cloudwatch:PutMetricData in the application role (and that action cannot be restricted to a specific metric name; you can restrict it by namespace with the cloudwatch:namespace condition key). Anyone who can read the log group can also read the metric values embedded in the lines, so the same data-minimisation rules apply: counts and timings are fine, customer identifiers are not.

How the lab emits its metrics

BankingMetrics.RecordTransfer writes one EMF line per transfer with two metrics (TransferCount, TransferLatency) under two dimension sets: [Service, Environment] and [Service, Environment, Outcome]. A real line from the lab's container (reformatted):

{
  "_aws": {
    "Timestamp": 1794988813199,
    "CloudWatchMetrics": [
      {
        "Namespace": "Harbourline/Payments",
        "Dimensions": [["Service", "Environment"], ["Service", "Environment", "Outcome"]],
        "Metrics": [
          { "Name": "TransferCount", "Unit": "Count" },
          { "Name": "TransferLatency", "Unit": "Milliseconds" }
        ]
      }
    ]
  },
  "Service": "transfers-api",
  "Environment": "learn",
  "Outcome": "failed",
  "TransferCount": 1,
  "TransferLatency": 29.8723,
  "correlationId": "01a1edab-ab5a-7c55-bda9-d95e2a2212e4",
  "scheme": "FPS",
  "level": "Metric"
}

Everything outside _aws is a normal log field. The dimension values (Service, Environment, Outcome) and the metric values (TransferCount, TransferLatency) are root members the directive points at. correlationId and scheme are properties: searchable in Logs Insights, but not dimensions, so they create no metrics and cost nothing extra.

Counting the metrics (and the cost)

Per metric name, the two dimension sets produce these series:

Dimension setSeriesCount
[Service, Environment]one, all outcomes combined1
[Service, Environment, Outcome]one per outcome: succeeded, rejected, failed3

Two metric names × 4 series = 8 custom metrics for this one service. At USD 0.30 per metric per month the list-price cost is USD 2.40, and after the free tier of 10 custom metrics, zero for the first service ⚠ VERIFY the free-tier applicability to your account. Now add scheme (5 values) as a third dimension: the [Service, Environment, Outcome, Scheme] set adds 15 series per name, so 30 more metrics. The lesson: each dimension set multiplies by the number of value combinations, so add dimension sets deliberately and only when an alarm or dashboard needs that breakdown.

Rule of thumb: a dimension is justified only if you will alarm or graph on it. If you only need to find things, make it a log property.

Step-by-step implementation

Name the metric and its question

"How many transfers fail per minute?" gives TransferCount with an Outcome dimension. "How slow is the tail?" gives TransferLatency with a p99 statistic. Write the question next to the name in code.

Fix the vocabulary

List every legal value of each dimension. The lab's Outcomes array has three entries, and RecordTransfer throws for anything else. That check is what keeps a typo (or an injected value) from creating new billed metrics.

Build the EMF document with validation

EmfWriter.Build checks the namespace, dimension count (30), metric count (100), the unit list, resolution (1 or 60) and that values are finite numbers. Failing in code is cheaper than silently losing data in CloudWatch.

Write the line to stdout, not through the logger

Use Console.Out.WriteLine (the lab's StdoutMetricSink). A logging framework would wrap the line in its own envelope and break the "pure JSON object" rule. Keep the logger for human-oriented events.

Check the timestamp source

Use the event's own time from TimeProvider. A host whose clock is more than two hours ahead, or a buffered replay older than 14 days, produces metrics CloudWatch quietly drops.

Verify in the console and the CLI

After the first line arrives allow a minute or two. Find the metric under CloudWatch → Metrics → All metrics → Harbourline/Payments, and read it back with the CLI. Also check the AWS/Logs namespace for EMF failure metrics.

Price it before you deploy

Count the series (dimension sets × value combinations × metric names), multiply by the price, subtract the free tier, and write the number in the pull request.

AWS Console instructions

Browse metrics: Console → CloudWatch → Metrics → All metrics. Choose the custom namespace Harbourline/Payments, then a dimension combination (for example Service, Environment, Outcome), tick the metrics and use the Graphed metrics tab to set the statistic (Sum for counts, p99 for latency) and period (one minute).

Find EMF problems: in All metrics choose the AWS/Logs namespace and look for the EMF failure metrics (names such as parsing or validation failures; see the EMF monitoring documentation ⚠ VERIFY exact names).

Remember that a metric appears only after its first data point, and that custom metrics cannot be deleted by you: they simply age out when no data arrives ⚠ VERIFY.

AWS CLI

# List the metrics in the namespace: this shows you the series you are paying for
aws cloudwatch list-metrics --namespace Harbourline/Payments --profile learn-sandbox \
  --query 'Metrics[].[MetricName,Dimensions[].Value|join(`,`,@)]' --output table

# Sum of failed transfers per minute for the last 15 minutes
aws cloudwatch get-metric-statistics --profile learn-sandbox \
  --namespace Harbourline/Payments --metric-name TransferCount \
  --dimensions Name=Service,Value=transfers-api Name=Environment,Value=learn Name=Outcome,Value=failed \
  --start-time "$(date -u -d '-15 minutes' +%FT%TZ)" --end-time "$(date -u +%FT%TZ)" \
  --period 60 --statistics Sum

# p99 latency, using an extended statistic
aws cloudwatch get-metric-statistics --profile learn-sandbox \
  --namespace Harbourline/Payments --metric-name TransferLatency \
  --dimensions Name=Service,Value=transfers-api Name=Environment,Value=learn \
  --start-time "$(date -u -d '-15 minutes' +%FT%TZ)" --end-time "$(date -u +%FT%TZ)" \
  --period 60 --extended-statistics p99

# Publish one data point by API (the alternative to EMF)
aws cloudwatch put-metric-data --namespace Harbourline/Payments --metric-name TransferCount \
  --dimensions Service=transfers-api,Environment=learn,Outcome=failed --value 1 --unit Count --profile learn-sandbox

Infrastructure as Code

Metrics created by EMF need no resource. What you manage as code is what reads them: alarms and dashboards (lessons 5 and 6) and, optionally, a log-group metric filter for lines you cannot change.

MetricFilterExample.cs
using Amazon.CDK.AWS.Logs;

// A metric filter counts log lines that match a JSON pattern: handy for code you cannot edit.
_ = new MetricFilter(this, "ServerErrors", new MetricFilterProps
{
    LogGroup = logGroup,
    MetricNamespace = "Harbourline/Payments",
    MetricName = "ServerErrorLines",
    FilterPattern = FilterPattern.Literal("{ $.statusCode >= 500 }"),
    MetricValue = "1",
    DefaultValue = 0,
});

A metric filter counts lines; EMF carries values (latency, amounts) and several metrics per line. Prefer EMF for code you own.

Complete code

The full writer is labs/m11-observe-banking-api/src/Harbourline.Observability/Metrics/EmfWriter.cs. The call site in the API is one line per outcome:

Program.cs (excerpt)
metrics.RecordTransfer("failed", ElapsedMs(), correlationId, "FPS");

BankingMetrics builds the document:

BankingMetrics.cs (excerpt)
public void RecordTransfer(string outcome, double latencyMs, string correlationId, string scheme)
{
    if (!Outcomes.Contains(outcome))
        throw new ArgumentException($"Outcome must be one of: {string.Join(", ", Outcomes)}.", nameof(outcome));

    var doc = EmfWriter.Build(
        Namespace,
        DimensionSets,                                   // [[Service, Environment], [Service, Environment, Outcome]]
        new Dictionary<string, string> { ["Service"] = _service, ["Environment"] = _environment, ["Outcome"] = outcome },
        [new EmfMetric(TransferCount, 1, "Count"), new EmfMetric(TransferLatency, latencyMs, "Milliseconds")],
        new Dictionary<string, object?> { ["correlationId"] = correlationId, ["scheme"] = scheme, ["level"] = "Metric" },
        _clock.GetUtcNow());

    _sink.Emit(doc);
}

The API-based alternative, for a script or batch job (compiles against AWSSDK.CloudWatch 4.1.1.2):

PutMetricDataExample.cs
using Amazon.CloudWatch;
using Amazon.CloudWatch.Model;

using var cw = new AmazonCloudWatchClient();

await cw.PutMetricDataAsync(new PutMetricDataRequest
{
    Namespace = "Harbourline/Payments",
    MetricData =
    [
        new MetricDatum
        {
            MetricName = "TransferCount",
            Dimensions =
            [
                new Dimension { Name = "Service", Value = "transfers-api" },
                new Dimension { Name = "Environment", Value = "learn" },
                new Dimension { Name = "Outcome", Value = "failed" },
            ],
            Unit = StandardUnit.Count,
            Value = 1,
            Timestamp = DateTime.UtcNow,
            StorageResolution = 60,
        },
    ],
});

// Read it back: Sum per minute over the last 15 minutes.
var stats = await cw.GetMetricStatisticsAsync(new GetMetricStatisticsRequest
{
    Namespace = "Harbourline/Payments",
    MetricName = "TransferCount",
    Dimensions =
    [
        new Dimension { Name = "Service", Value = "transfers-api" },
        new Dimension { Name = "Environment", Value = "learn" },
        new Dimension { Name = "Outcome", Value = "failed" },
    ],
    StartTime = DateTime.UtcNow.AddMinutes(-15),
    EndTime = DateTime.UtcNow,
    Period = 60,
    Statistics = [Statistic.Sum],
});
foreach (var point in stats.Datapoints.OrderBy(p => p.Timestamp))
    Console.WriteLine($"{point.Timestamp:HH:mm} sum={point.Sum}");

Code explained line by line

  1. Outcomes.Contains(outcome) is the cardinality guard. Without it, a code path that passed ex.Message as the outcome would create a new billed metric per exception message.
  2. DimensionSets is a list of lists. Each inner list is one combination CloudWatch publishes. Both inner lists name Outcome or not; the dimension values are supplied once, at the root.
  3. new EmfMetric(TransferCount, 1, "Count") records a data point of 1 per transfer. CloudWatch sums the ones per minute, giving transfers per minute. (If you had one line per minute with a pre-aggregated count, you would publish that count instead.)
  4. latencyMs is a continuous value; per minute CloudWatch computes min, max, sum, count and percentile estimates from the values received, so p99 works with no extra effort.
  5. The properties dictionary becomes ordinary JSON fields. level = "Metric" tags EMF lines so queries for errors can ignore them.
  6. _clock.GetUtcNow() supplies _aws.Timestamp in milliseconds. Using TimeProvider makes the output deterministic in tests (the lab's EmfWriterTests use a fixed instant).
  7. In the SDK sample, StandardUnit.Count and Statistic.Sum are constant classes in SDK v4, and Timestamp, StartTime and EndTime are DateTime values in UTC. The collection initialisers ([...]) rely on the SDK v4 list properties being initialised for you.

Security considerations

⚠ Learning shortcut — not for production

The lab runs under one sandbox identity, and put-metric-data is shown with full access to the sandbox account. In production, give an application that must call the API only cloudwatch:PutMetricData with a cloudwatch:namespace condition for its own namespace, and prefer EMF so the application needs no CloudWatch permission at all.

  • Metric data is not secret but it is still data. A dimension such as Outcome=failed is harmless; customerId is not. Keep identifiers out of metrics.
  • Control cost as a security issue. A bug or attacker that causes unbounded distinct dimension values (for example from user input) creates unbounded metrics. Validate dimension values against a fixed list; the lab's BankingMetrics does.
  • IAM scope for PutMetricData. The action does not support resource-level restrictions, but the cloudwatch:namespace condition key does limit which namespace the caller may write to. Check the current condition keys ⚠ VERIFY.
  • Who can read. cloudwatch:GetMetricData, GetMetricStatistics and ListMetrics are the read actions. Give them to operations roles.
  • Alarms depend on honest metrics. If an application can falsify its own counts, alarms can be silenced. For safety-critical signals use a measurement taken outside the application (load balancer metrics, canaries) as well.

Banking use case

Harbourline's payments service publishes TransferCount by Outcome and TransferLatency for each transfer. Operations alarm on Outcome=failed (more than five per minute in three of five minutes) and on total traffic falling below one per minute during business hours, and page only when customers are affected. The business dashboard graphs rejected separately: a spike in rejections is often a client-side deployment bug, not a platform incident, and it should reach the product team, not the infrastructure on-call. The settlement scheme (FPS, BACS, CHAPS) is a log property: operations can filter by it in Logs Insights when needed, without paying for 15 extra metrics. Data is fictional.

Common mistakes

  • High-cardinality dimensions (customerId, paymentId, scheme × outcome × endpoint all together). Fix: fixed vocabularies; properties for the rest.
  • Wrapping EMF in the logger. The envelope breaks extraction. Fix: write the raw JSON line to stdout.
  • Wrong statistic. Averaging a counter hides spikes. Fix: Sum for counts, p95/p99 for latency.
  • Mismatched dimension values between the code and the alarm (transfers-api vs transfer-api). Fix: one constant shared by the app and the infrastructure code, as the lab's CDK stack mirrors the C# names.
  • Timestamps outside the window. Replaying old logs produces nothing. Fix: use the event time and check it against the 14-day and 2-hour limits.
  • Using PutMetricData in a hot path. It adds latency and a permission. Fix: EMF.
  • Expecting instant data. Metrics lag a minute or more. Fix: design alarms with that lag in mind.

Troubleshooting

SymptomLikely causeFix
Metric never appearsThe line is not a single JSON object, the _aws block is invalid, or the timestamp is out of rangeRun aws logs tail and inspect the line; check AWS/Logs EMF failure metrics
Metric appears under the wrong dimensionsDimension names not in the directive, or values missing at the rootCompare the Dimensions array with the root keys
get-metric-statistics returns no data pointsDimension values differ, period too short, or time range wrongList metrics first and copy the exact dimension values
Bill is highA high-cardinality dimension or too many dimension setslist-metrics the namespace and count the series
Duplicate countsEMF delivery is at least onceDo not use for billing; use alarm thresholds that tolerate small duplication
Percentile statistic missingPercentiles need extended statistics, not --statisticsUse --extended-statistics p99

Cost and cleanup

At lab volume (tens of transfers) the data cost is negligible. The custom metrics: eight series, USD 2.40 per month at list price, and inside the free tier of 10 custom metrics if nothing else in the account uses it ⚠ VERIFY. Log ingestion for the lines is a few kilobytes. Metrics cannot be deleted; they stop being billed when no data arrives (billing is per metric that received data in the month ⚠ VERIFY), so the clean-up is to stop publishing and delete the log group.

# Stop publishing: destroy the stack and the log group
cd labs/m11-observe-banking-api/infra/cdk && cdk destroy --profile learn-sandbox
aws logs describe-log-groups --log-group-name-prefix /hl-m11 --profile learn-sandbox
aws cloudwatch list-metrics --namespace Harbourline/Payments --profile learn-sandbox   # metrics age out on their own

Exercises

  • 🟢 Guided: Run the lab's EmfWriterTests and BankingMetricsTests. Then read the EMF line the container writes (docker compose up, scripts/load.sh, docker compose logs api) and identify: the namespace, both dimension sets, the metric names, one property.
  • 🟡 Challenge: Add a metric TransferAmountGbp (unit None, sum per minute) to BankingMetrics for successful transfers only, with a unit test. Count the new metric series and the monthly list cost.
  • 🔴 Live problem: The billing alert shows custom metrics jumped from 8 to 40,000 overnight. A release added endpoint (taken from the raw request path, which contains account IDs) as a dimension. Write the response: how you confirm the cause with list-metrics, how you fix the code, what happens to the metrics already created, how you stop it happening again (tests, review rule, an alarm on the AWS/Usage or billing metrics ⚠ VERIFY), and what you tell finance.

Assignment

Add EMF business metrics to a service of your own: a counter by outcome and a latency value, with a validated vocabulary and unit tests that assert the document structure. Document the metric series count and the list price in the README, and add one alarm definition (CDK or Terraform) that reads one of the metrics.

Solutions

Knowledge check

Interview questions

  • How do you publish a business metric from ECS without an SDK call? Write an EMF JSON line to stdout; the awslogs driver ships it and CloudWatch Logs extracts the metrics.
  • What is a dimension and why is cardinality a cost issue? A dimension is a name/value pair that identifies a series; each combination is a separate custom metric billed monthly, so unbounded values mean unbounded cost.
  • EMF versus a metric filter? EMF carries numeric values and multiple metrics in a line you control; a metric filter counts or extracts values from lines you cannot change.
  • How would you alarm on latency? Use p95 or p99 over a one-minute period with M-out-of-N evaluation, not the average.
  • What can go wrong with EMF? Invalid JSON or wrapped lines, timestamps outside the window, mismatched dimension values, and unbounded dimensions.

Certification practice

Completion checklist

  • I can name the parts that identify a CloudWatch metric
  • I can write (or read) a valid EMF document and name its limits
  • I counted the series and the list cost for the lab's metrics
  • I read a metric back with the CLI
  • I stopped publishing and removed the lab's log group

Key takeaways

  • A metric is identified by namespace, name and the exact dimension combination; each combination is billed.
  • EMF turns a log line into metrics with no API call and no application permission, if the line is pure JSON and the timestamp is in range.
  • Dimensions are for breakdowns you will alarm or graph on; everything else is a property.
  • Use Sum for counters and percentiles for latency.
  • Price the series count before deploying; write the number in the pull request.

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