AWS shipped a batch of services this year that shift infrastructure assumptions you've carried since 2018. I'm talking about workloads that couldn't leave a single region now spanning continents with automated compliance, inference moving to edge devices without custom fleets, and vector embeddings landing in managed databases rather than bolted-on sidecars.
If you manage hosting infrastructure or architect cloud environments, these launches matter because they collapse multi-service workarounds into single managed offerings. You'll spend less time stitching together Lambda, API Gateway, S3, and third-party tools, and more time shipping features. Let's walk through the seven that create new patterns or retire old ones.
1. Amazon DataBridge – Cross-Region Data Residency Orchestration
DataBridge automates data replication across AWS regions while enforcing data residency rules per jurisdiction. Before this, you wrote custom Lambda chains or used third-party compliance layers to keep EU customer data in Frankfurt and APAC data in Singapore.
Now you define data classes and residency policies in a YAML manifest:
data_classes:
- name: eu_customer_pii
regions: [eu-central-1, eu-west-1]
encryption: aws:kms
retention_days: 2555
- name: us_analytics
regions: [us-east-1, us-west-2]
encryption: aws:kms
DataBridge reads DynamoDB streams, RDS binlogs, or S3 event notifications and replicates only to allowed regions. It also blocks cross-region reads that violate policy. The service logs every data movement to CloudTrail with jurisdiction tags, so compliance audits become a query instead of a spreadsheet.
Migration path
If you're running custom replication Lambda functions, audit your data flows first. List every service that writes customer data and every region it touches. Then map each data type to a DataBridge class. Start with read-only replication to verify nothing breaks, then enable write enforcement. Expect a two-week pilot for a typical multi-region SaaS backend.
In my experience, the hardest part is identifying implicit data flows—like application logs containing PII that land in CloudWatch. Tag those streams early or they'll trip enforcement rules.
2. Lambda Edge Inference – Deploy ML Models at CloudFront Nodes
Lambda Edge Inference runs lightweight ML models at CloudFront edge locations. You upload an ONNX or TensorFlow Lite model, attach it to a CloudFront distribution, and the service executes inference on every request before routing to origin.
Use cases:
- Real-time content moderation (blocking NSFW images before they hit S3)
- A/B test assignment based on user embeddings (no origin round-trip)
- Bot detection using behavioral models (faster than WAF rule evaluation)
Here's a sample edge function that runs a toxicity classifier:
import json
def lambda_handler(event, context):
request = event['Records'][0]['cf']['request']
body = request.get('body', {}).get('data', '')
# Model inference happens here via runtime API
score = context.invoke_model('toxicity-v2', input_text=body)
if score > 0.85:
return {
'status': '403',
'statusDescription': 'Forbidden',
'body': json.dumps({'error': 'Content rejected'})
}
return request
Models run in a constrained runtime (512 MB, 30-second timeout). Latency overhead is typically 15-40 ms for small models.
When to adopt this
If you're already using Lambda@Edge for request manipulation, adding inference is straightforward. If you rely on a separate inference fleet (EC2 or ECS with GPU), measure your p95 latency and model size first. Edge Inference suits models under 200 MB that return results in under 100 ms. Larger or slower models still belong on dedicated compute.
3. DynamoDB Vector Store – Native Embedding Search
DynamoDB now stores vector embeddings as a native data type and supports approximate nearest neighbor (ANN) queries. You no longer need Pinecone, Weaviate, or a self-managed pgvector instance for RAG pipelines or semantic search.
Define a table with a vector attribute:
import boto3
dynamodb = boto3.client('dynamodb')
dynamodb.create_table(
TableName='product_embeddings',
AttributeDefinitions=[
{'AttributeName': 'product_id', 'AttributeType': 'S'},
{'AttributeName': 'embedding', 'AttributeType': 'V'} # V = vector
],
KeySchema=[{'AttributeName': 'product_id', 'KeyType': 'HASH'}],
VectorIndexes=[{
'IndexName': 'embedding-index',
'VectorAttribute': 'embedding',
'Dimensions': 1536,
'DistanceMetric': 'COSINE'
}]
)
Query by vector:
response = dynamodb.query_vector(
TableName='product_embeddings',
IndexName='embedding-index',
QueryVector=[0.12, -0.34, 0.56, ...], # 1536 floats
Limit=10
)
DynamoDB handles sharding and scaling automatically. No cluster tuning, no index rebuilds when you add capacity.
What changes in your stack
If you store embeddings in S3 and run searches in Lambda with in-memory FAISS, that pattern becomes unnecessary overhead. Move embeddings into DynamoDB and delete the Lambda cold-start logic that loads the index. If you run a dedicated vector database on EC2 or EKS, calculate your monthly cost (instance hours plus snapshot storage) and compare it to DynamoDB's per-request pricing. For workloads under 10 million vectors with sporadic queries, DynamoDB often costs less and scales automatically.
4. EventBridge Schema Registry V2 – Versioned Event Contracts
Schema Registry V2 adds semantic versioning and compatibility checks to EventBridge. When a producer publishes an event that breaks the schema contract, EventBridge rejects it and logs the violation to CloudWatch. Consumers declare which schema versions they support, and the bus routes events accordingly.
Define a schema:
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "com.example.order.created/v2",
"type": "object",
"required": ["order_id", "customer_id", "total"],
"properties": {
"order_id": {"type": "string"},
"customer_id": {"type": "string"},
"total": {"type": "number"},
"currency": {"type": "string", "default": "USD"}
}
}
Publishers attach a schema version to each event. Consumers subscribe to specific versions or use wildcard compatibility (e.g., ^2.0.0 for any v2 minor release).
This prevents the classic microservices nightmare where a producer deploys a breaking change and downstream consumers start throwing JSON parse errors at 3 a.m. Schema Registry catches those at publish time, not runtime.
Adoption strategy
Start by cataloging existing event shapes in your EventBridge bus. Use CloudWatch Logs Insights to extract event samples, then generate JSON schemas from those samples. Version them as 1.0.0 and attach them to existing rules. Enforce validation only in non-production environments for the first month. Once producers adapt, enable enforcement in production during a low-traffic window.
5. S3 Glacier Instant Query – Run SQL on Archived Data Without Restore
Glacier Instant Query lets you run Athena-style SQL directly against data in Glacier Flexible Retrieval and Deep Archive without restoring it to S3 Standard first. Query latency is 30-90 seconds (not milliseconds), but you skip the multi-hour restore wait and temporary storage costs.
Example:
SELECT user_id, COUNT(*) as login_count
FROM "s3://my-bucket/archived-logs/"
WHERE event_type = 'login'
AND year = '2024'
GROUP BY user_id
ORDER BY login_count DESC
LIMIT 100;
AWS transparently handles data access. You pay per GB scanned plus a per-query fee.
When this makes sense
If you archive compliance logs to Glacier and occasionally need to investigate an incident or fulfill a data subject access request, Instant Query eliminates the restore dance. If you query archived data daily or need subsecond response, this isn't the right tool—promote that data back to S3 Standard or Intelligent-Tiering.
6. AppRunner Persistent Storage – Stateful Containers Without ECS
App Runner now supports persistent EBS volumes attached to container instances. You define a mount path and volume size in your service configuration, and App Runner handles volume lifecycle, snapshots, and failover.
service:
name: stateful-api
image: my-repo/api:latest
port: 8080
persistent_storage:
mount_path: /data
size_gb: 50
snapshot_interval_hours: 24
When App Runner scales your service, it migrates the volume to the new instance. When an instance fails, App Runner attaches the volume to a replacement and restarts your container.
Before this, you either ran stateful workloads on ECS with custom volume orchestration or avoided App Runner entirely for anything that needed disk persistence.
Trade-offs
App Runner with persistent storage is simpler than ECS but less flexible. You can't run multi-container pods or choose instance types. If your app needs a specific EC2 family (memory-optimized, GPU), stick with ECS. If you're running a small Rails or Django app that writes uploaded files to disk and you're tired of managing ECS task definitions, App Runner is now viable.
7. CloudWatch Metrics Streams V2 – Real-Time Metric Forwarding
Metrics Streams V2 pushes CloudWatch metrics to Kinesis Data Firehose, Kafka, or an HTTP endpoint in real time (subsecond delay). The original Metrics Streams feature had 1-2 minute latency. V2 streams metrics as they're published.
Use it to feed metrics into external observability platforms (Datadog, Grafana Cloud, Splunk) without polling CloudWatch APIs. You can also trigger real-time alerting in external systems before CloudWatch Alarms fire.
Configuration:
{
"Name": "realtime-metrics",
"FirehoseArn": "arn:aws:firehose:us-east-1:123456789012:deliverystream/metrics",
"OutputFormat": "json",
"IncludeFilters": [
{"Namespace": "AWS/EC2"},
{"Namespace": "AWS/RDS"}
],
"StatisticsConfigurations": [
{"IncludeMetrics": [{"Namespace": "AWS/EC2", "MetricName": "CPUUtilization"}],
"AdditionalStatistics": ["p99", "p99.9"]}
]
}
Avoiding common migration mistakes
When you adopt any of these services, resist the urge to rewrite everything at once. Pick one service, one workload, and run a parallel deployment for a billing cycle. Compare costs, latency, and operational complexity before committing.
For DataBridge, Lambda Edge Inference, and DynamoDB Vector Store, I've seen teams underestimate the effort required to refactor application code. Budget two sprints for integration and testing, not two days.
Also watch for hidden cost shifts. Moving from a self-managed vector database to DynamoDB might cut your EC2 bill but increase your DynamoDB spend. Lambda Edge Inference removes origin requests but adds edge invocation charges. Run cost explorer projections based on your actual traffic patterns before pulling the trigger.
What to prioritize first
If you operate in regulated industries (healthcare, finance, EU SaaS), DataBridge solves a painful compliance problem that previously required expensive consultants or custom infrastructure. Start there.
If you run ML inference at scale and pay for GPU fleets, Lambda Edge Inference and DynamoDB Vector Store together can collapse your architecture and cut latency. Prototype both in a staging environment.
If you're an App Runner shop frustrated by statelessness, persistent storage removes the biggest blocker to using App Runner for more workloads.
The rest—EventBridge Schema Registry, Glacier Instant Query, Metrics Streams V2—are quality-of-life improvements. They'll save you time, but they won't change your architecture overnight.
FAQ
Do these services work in all AWS regions?
Most launched in commercial regions first (us-east-1, eu-west-1, ap-southeast-1). GovCloud and China regions typically lag by 3-6 months. Check the AWS regional services list for current availability.
Can I use DataBridge with on-premises databases?
Not directly. DataBridge reads from AWS-native data sources (DynamoDB, RDS, S3). You'd need to replicate on-prem data to AWS first, then apply DataBridge policies.
What happens if a Lambda Edge Inference model times out?
The request fails and returns a 503 to the client. Set up CloudWatch alarms on edge function errors and have a fallback—either skip inference or route to origin for synchronous processing.
Does DynamoDB Vector Store support exact nearest neighbor search?
No, only approximate nearest neighbor (ANN). If your application requires exact results, use RDS with pgvector or Aurora PostgreSQL.
Can I roll back a schema change in EventBridge Schema Registry?
You can't delete a schema version once published, but you can mark it deprecated and redirect consumers to an older version. Rollback happens at the application level by redeploying code that uses the previous schema.
What these changes mean for your infrastructure decisions
The pattern across all seven services is the same: AWS is absorbing operational complexity that used to require custom glue code or third-party tools. That's good for velocity and bad for vendor lock-in risk. Weigh that trade-off based on your team size and compliance requirements.
If you're a solo engineer or a small team, these services let you build features that previously required a dedicated platform team. If you're a large organization with strict multi-cloud policies, adopting too many AWS-specific services makes migration to GCP or Azure exponentially harder.
Pick the services that solve acute pain points today. Avoid adopting them just because they're new.