Forem: Praneeta Prakash

CDK update - March 2026

Praneeta Prakash — Thu, 09 Apr 2026 15:38:45 +0000

Index

TL;DR
Major Features
- CDK Mixins — From Preview to Stable
- EKS v2 Graduates to Stable
- CLI Improvements
- New L2 Constructs
- Service Enhancements
Community Highlights
Community Content & Resources
How Can You Be Involved

Hey CDK community! Here’s an update on all the changes that happened last month.

TL;DR

CDK Mixins are now stable in aws-cdk-lib — compose reusable infrastructure behaviors across any construct without extra packages. EKS v2 graduated to stable with production-ready APIs. And the CLI shipped --revert-drift to fix drifted resources in a single command.

These features are available in aws-cdk-lib v2.233.0 through v2.248.0 and aws-cdk CLI v2.1099.0 through v2.1117.0. Full changelogs on GitHub Releases.

Major Features

CDK Mixins — From Preview to Stable

If you've been waiting to adopt Mixins, the wait is over. The core Mixins API (Mixins.of(), Mixin, ConstructSelector) landed in aws-cdk-lib in February, and the @aws-cdk/cfn-property-mixins package graduated to stable in March. That means the fluent .with() method now works on any construct — L1, L2, or custom — directly from aws-cdk-lib, no extra packages needed.

Several service mixins ship directly in aws-cdk-lib:

// Apply mixins fluently with .with() — works on L1, L2, and custom constructs
new s3.CfnBucket(scope, 'MyL1Bucket')
  .with(new s3.mixins.BucketBlockPublicAccess())
  .with(new s3.mixins.BucketAutoDeleteObjects());

// Auto-delete ECR images on repository removal
new ecr.CfnRepository(this, 'Repo')
  .with(new ecr.mixins.RepositoryAutoDeleteImages());

// Apply cluster settings to L1 constructs
new ecs.CfnCluster(this, 'Cluster')
  .with(new ecs.mixins.ClusterSettings([{ name: 'containerInsights', value: 'enhanced' }]));

// .with() works on L2 constructs too
new s3.Bucket(stack, 'MyL2Bucket')
  .with(new s3.mixins.BucketBlockPublicAccess());

Already using Aspects? The new Shims class lets you convert between Aspects and Mixins, so you can adopt incrementally without rewriting existing code.

Also new in the Mixins Preview package: EventBridge pattern generation for all events, custom merge strategies via IMergeStrategy, cross-account Vended Log delivery destinations, and the ability to pass resource objects directly into CFN Property mixin properties.

EKS v2 Graduates to Stable 🚀

The @aws-cdk/aws-eks-v2-alpha module is now aws-cdk-lib/aws-eks-v2 — stable APIs, no more alpha imports, production-ready. If you've been holding off on EKS v2 because of the alpha label, it's time to upgrade.

Alongside graduation, February brought Kubernetes 1.35 support, hybrid nodes for on-premises and edge infrastructure, EC2/HYBRID_LINUX/HYPERPOD_LINUX access entry types, removal policies for all EKS constructs, and bootstrapSelfManagedAddons support.

import { KubectlV35Layer } from '@aws-cdk/lambda-layer-kubectl-v35';

const cluster = new eks.Cluster(this, 'Cluster', {
  version: eks.KubernetesVersion.V1_35,
  kubectlLayer: new KubectlV35Layer(this, 'KubectlLayer'),
  remoteNodeNetworks: [
    {
      cidrs: ['10.0.0.0/16'],
    },
  ],
  remotePodNetworks: [
    {
      cidrs: ['192.168.0.0/16'],
    },
  ],
});

CLI Improvements

`--revert-drift` Option

Drifted resources used to mean manual remediation. Now a single flag on cdk deploy creates a drift-aware change set that brings your actual resource state back in line with your template:

$ cdk deploy --revert-drift MyStack

Concurrent Asset Builds & `publish-assets`

Two features that speed up CI/CD pipelines. Build assets in parallel with --asset-build-concurrency, and separate asset publishing from deployment with the new publish-assets command:

$ cdk deploy --asset-build-concurrency 4
$ cdk publish-assets MyStack --unstable=publish-assets

`cdk diff --method` & `cdk destroy --concurrency`

cdk diff now supports --method=change-set to always use a change set (and fail if it can't), replacing the deprecated --change-set flag. And cdk destroy gained --concurrency for parallel stack destruction.

Contributed by: Mike Voets (destroy --concurrency)

Additional CLI Updates

Guard Hook failure details — the CLI now fetches and displays detailed failure annotations automatically (jkelley-godaddy)
Fn::ForEach diff support — ForEach loops are no longer invisible in cdk diff
Metadata in separate files — avoids the 512MB NodeJS string limit for extremely large apps
Changeset-based diff for nested stacks — accurate diffs including --security-only
cdk import fix — --role-arn no longer conflicts with --record-resource-mapping (Abhishek Chauhan)
Docker buildSecrets fix — secrets are now correctly passed to docker build (cartmanez)

New L2 Constructs

MediaPackage V2 (Alpha)

A full-featured L2 for AWS Elemental MediaPackage V2 — channel groups, channels, origin endpoints, manifests (HLS, DASH, LL-HLS, MSS), encryption/DRM, type-safe manifest filtering, grants, and CloudWatch metrics. Everything you need to set up a streaming pipeline in CDK:

import { ChannelGroup, Channel, OriginEndpoint, InputConfiguration, Segment, Manifest } from '@aws-cdk/aws-mediapackagev2-alpha';

const group = new ChannelGroup(stack, 'MyChannelGroup', {
  channelGroupName: 'my-channel-group',
});

const channel = group.addChannel('MyChannel', {
  channelName: 'my-channel',
  input: InputConfiguration.cmaf(),
});

const endpoint = channel.addOriginEndpoint('MyEndpoint', {
  originEndpointName: 'my-endpoint',
  segment: Segment.cmaf(),
  manifests: [Manifest.hls({ manifestName: 'index' })],
});

// Grant MediaLive permission to ingest content
channel.grants.ingest(mediaLiveRole);

See the full README for manifest filtering, encryption, and DRM examples.

Service Enhancements

DynamoDB Cross-Account Global Tables

Replicate tables across AWS accounts for multi-tenant architectures and disaster recovery. Permissions are automatically configured when both tables are in the same CDK app:

const sourceTable = new dynamodb.TableV2(sourceStack, 'SourceTable', {
  tableName: 'MyMultiAccountTable',
  partitionKey: { name: 'pk', type: dynamodb.AttributeType.STRING },
  globalTableSettingsReplicationMode: dynamodb.GlobalTableSettingsReplicationMode.ALL,
});

// Replica in Account B — resource policies and KMS permissions handled for you
const replica = new dynamodb.TableV2MultiAccountReplica(replicaStack, 'ReplicaTable', {
  tableName: 'MyMultiAccountTable',
  replicaSourceTable: sourceTable,
  globalTableSettingsReplicationMode: dynamodb.GlobalTableSettingsReplicationMode.ALL,
});

ALB JWT Authentication

Verify JWTs directly at the load balancer for service-to-service auth — no custom Lambda authorizers needed:

const listener = lb.addListener('Listener', {
  protocol: elbv2.ApplicationProtocol.HTTPS,
  port: 443,
  certificates: [certificate],
  defaultAction: elbv2.ListenerAction.authenticateJwt({
    issuer: 'https://issuer.example.com',
    jwksEndpoint: 'https://issuer.example.com/.well-known/jwks.json',
    next: elbv2.ListenerAction.forward([myTargetGroup]),
  }),
});

Contributed by: Kazuho Cryer-Shinozuka

OpenSearch S3 Vectors Engine

Sub-second vector search at lower cost by offloading vector data to S3:

const domain = new Domain(this, 'Domain', {
  version: EngineVersion.OPENSEARCH_2_19,
  s3VectorsEngineEnabled: true,
  capacity: { dataNodeInstanceType: 'or1.medium.search' },
  encryptionAtRest: { enabled: true },
});

Contributed by: Kazuho Cryer-Shinozuka

Kinesis Firehose Dynamic Partitioning

Partition streaming data on the fly using JQ expressions — no Lambda required:

const s3Destination = new firehose.S3Bucket(bucket, {
  dynamicPartitioning: { enabled: true },
  processors: [
    firehose.MetadataExtractionProcessor.jq16({
      customer_id: '.customer_id',
      year: '.event_timestamp|strftime("%Y")',
    }),
  ],
  dataOutputPrefix: '!{partitionKeyFromQuery:year}/!{partitionKeyFromQuery:customer_id}/',
});

Contributed by: Tietew

Glue Typed Partition Projection (Alpha)

Type-safe partition projection for Glue tables — no more raw strings for integer, date, enum, and injected types:

new glue.S3Table(this, 'MyTable', {
  database: myDatabase,
  columns: [{ name: 'data', type: glue.Schema.STRING }],
  partitionKeys: [{ name: 'year', type: glue.Schema.INTEGER }],
  dataFormat: glue.DataFormat.JSON,
  partitionProjection: {
    year: glue.PartitionProjectionConfiguration.integer({
      min: 2020, max: 2023, interval: 1, digits: 4,
    }),
  },
});

Contributed by: Kazuho Cryer-Shinozuka

Bedrock AgentCore: `fromCodeAsset`

Deploy agent runtimes from local code with automatic S3 packaging — no pre-built container required:

const artifact = agentcore.AgentRuntimeArtifact.fromCodeAsset({
  path: path.join(__dirname, 'path/to/agent/code'),
  runtime: agentcore.AgentCoreRuntime.PYTHON_3_12,
  entrypoint: ['opentelemetry-instrument', 'main.py'],
});

new agentcore.Runtime(this, 'MyAgentRuntime', {
  runtimeName: 'myAgent',
  agentRuntimeArtifact: artifact,
});

Contributed by: Kenta Goto (fromCodeAsset)

More Service Updates

API Gateway: TLS 1.3 enhanced security policies with post-quantum cryptography support
EC2: VPC flow logs to Amazon Data Firehose (Tietew)
ECS: forceNewDeployment() to trigger redeployment without definition changes
AutoScaling: Deletion protection and instance lifecycle policy with retention triggers (Masatomo Nomura)
RDS: Standalone ParameterGroup.forInstance() / ParameterGroup.forCluster() factory methods
S3: Blocked encryption types to control allowed upload encryption (Yash Thakur), ABAC support (Kazuho Cryer-Shinozuka)
ECR Assets: Docker buildContexts for multi-context builds
CloudFront: JS runtime 2.0 as default for new projects (Kazuho Cryer-Shinozuka)
S3 Tables (Alpha): Tagging, metrics, partition specs, sort orders (Michael Garbus, Olena R)
API Gateway V2: Role support for Lambda authorizers (Elias Brange)
Synthetics: Canary NodeJS 3.1 runtime (Bilal Quadri)

Community Highlights

Top External Contributors

Kazuho Cryer-Shinozuka — 8 contributions across ALB JWT auth, OpenSearch S3 Vectors, S3 ABAC, Glue typed partition projection, CloudFront JS 2.0 default, and more. A driving force behind CDK's service coverage.

Kenta Goto — Three high-impact features: publish-assets CLI command, concurrent asset builds, and Bedrock AgentCore fromCodeAsset. Consistently shipping features that improve developer velocity.

aki-kii — Built --revert-drift for the CLI and added AppSync enhanced metrics. Contributions spanning both CLI and construct library.

Tietew — Kinesis Firehose dynamic partitioning and EC2 flow log Firehose destinations — two highly requested features.

Masatomo Nomura — AutoScaling deletion protection and instance lifecycle policy across both months.

Olena R — S3 Tables metrics, partition specs, sort orders, and table properties.

Additional Contributors

Andre Kurait, Dave Dennis, Mike Voets, Elias Brange, David Konigsberg, Michael Garbus, Yuki Matsuda, Yash Thakur, Bilal Quadri, Bryan Koch, syukawa-gh, jkelley-godaddy, Juho Majasaari, Abhishek Chauhan, cartmanez

Community Content & Resources

From the Community:

AWS CDK Tips: How to Centrally Apply Configurations to Multiple Resources — Kenta Goto walks through patterns for applying configurations at scale — timely with Mixins going stable.

CDK Mixin for Deletion Protection — Hands-on walkthrough of building a custom Mixin, by johanneskonings.

Why is cdk.out (Cloud Assembly) Necessary in AWS CDK? — Kenta Goto explains the Cloud Assembly and why it matters for your workflow.

CDK - Using Central Register Pattern for Resource Sharing — A practical pattern for sharing resources across stacks, by tyckofranklin.

CDK Infrastructure for Amazon Bedrock AgentCore (And Every Gotcha You'll Hit) — Real-world guide to deploying Bedrock AgentCore with CDK, by rajmurugan.

Zero Orphaned Resources: Force Deleting Any CloudFormation Stack — Kenta Goto on cleaning up stuck stacks without leaving orphaned resources.

What Really Happens When You Deploy with AWS CDK? — A look under the hood at the CDK deployment process, by mianzubair.

Building a Serverless LLM Pipeline with Bedrock and SageMaker using CDK — End-to-end CDK pipeline for LLM fine-tuning, by katevu.

Resources:

AWS IaC MCP Server — AI-powered CDK development via Model Context Protocol.
CDK Construct Hub — Discover community-built constructs.
AWS CDK API Reference

How Can You Be Involved

Report Issues

Open an issue on GitHub.

Contribute Code

Check our contributing guide and look for good first issue or help wanted labels.

Join the Conversation

Slack: CDK.dev community
GitHub: Discussions
Stack Overflow: aws-cdk tag

Star the Repo

Give us a star on GitHub! ⭐

Feedback? Share in GitHub Discussions.

From One Prompt to a Deployed Full-Stack App on AWS

Praneeta Prakash — Wed, 11 Mar 2026 19:56:49 +0000

By H. Furkan Bozkurt

Let's build a travel journal app. The kind where users sign in, create trips, write journal entries, upload photos, and chat with an AI companion that knows about their travels. Auth, data modelling, file storage, AI conversation, a Next.js frontend, and a production deployment. The usual full-stack checklist together with some AI features that takes a weekend to wire up manually.

We'll do it with one prompt. The agent will work through a 4-phase plan (backend, sandbox, frontend, production), pausing between each phase to ask for the go-ahead before continuing with the help of AWS Amplify Power!

Prerequisites

Node.js 18.x or later
npm available
AWS credentials configured (aws configure or aws sso login)
- For setting up AWS account with Amplify permissions, see the Amplify account setup guide and the AWS MCP prerequisites.
Kiro IDE installed

What's a Kiro Power?

Before we move forward with implementation, let’s talk about Kiro Powers. Kiro Powers are packaged workflows for the Kiro IDE. They bundle tools, instructions, and structured execution plans into a single installable unit. You don't configure them manually or edit JSON files. You install one from the sidebar with a click, and it activates automatically when your prompt is relevant.

Setup

Now you are ready to build the application. Let’s get started with installing the Kiro Power.

Installation

Click the Powers icon (lightning bolt) in Kiro IDE's right sidebar
Click Build full-stack apps with AWS Amplify
Click Install

That's it. No JSON config files, no manual server setup. Let's build something.

The Prompt

Here's what we'll give the agent. Notice there's no mention of Cognito, S3, DynamoDB, or deployment pipelines. We just describe the app we want:

Build "Leafer", a travel journal app where users sign in, create trips, write journal entries, and upload photos. Include a chat feature that can answer questions about the user's trips and entries, things like "summarize my Barcelona trip" or "what restaurants did I mention in Japan?" Use Next.js with TypeScript for the frontend. For the backend, set up auth, a data model, file storage, and a conversational AI backend. Make the UI clean and deploy it to production.

Hit enter. The agent activates the Amplify Power as the first thing.

Then it validates prerequisites (Node.js, AWS credentials), and presents a plan: the features it identified, the framework it will use, and the phases it will execute.

Phase 1: Backend Setup

The agent starts by building the backend. It retrieves the relevant Amplify backend SOP and creates the resources: authentication (Cognito), a data model (trips, journal entries), file storage (S3 for photos), and an AI conversation route that has context about the user's trips and entries.

Once done, it lists everything it created and asks for confirmation before moving forward.

Not every task triggers all four phases. If you'd asked "add auth to my existing backend," the agent would run only this phase and the sandbox deployment, skipping frontend and production entirely. The Power is context-aware: it reads the prompt and the project's current state to decide which phases apply.

Phase 2: Sandbox Deployment

With the backend defined, the agent deploys everything to a sandbox environment. This is where you catch issues like schema problems, permission misconfigurations, or missing environment variables before anything touches production.

The agent follows the Amplify deployment SOP, runs the sandbox deployment, and pauses again for confirmation.

Phase 3: Frontend & Testing

With the sandbox running, the agent moves to the frontend. It scaffolds the Next.js app, installs the Amplify client libraries, and builds the UI: an authentication flow, trip management pages, journal entry forms with photo uploads, and the AI companion chat interface.

After the build succeeds, the agent generates a testing checklist based on the specific resources that were created. Not a generic list: if you didn't add storage, storage tests won't appear.

This is the phase where you open the app locally, click through the flows, and verify everything works before shipping.

Phase 4: Production Deployment

The final phase sets up CI/CD deployment through Amplify Hosting. The agent follows the deployment SOP again, this time configuring a production pipeline connected to the repository.

Future updates just need a git push to main. Amplify picks up the change and auto-deploys.

One thing worth noting: the generated frontend gives you a working app with all the right integrations, but it's a starting point. For a production app, you'll want to spend time refining the UI, tightening up the layout, and making it your own. The value is in the wiring, not the pixel-perfect design.

One prompt, four phases, and a few confirmation clicks later: Leafer is live!

Cleanup

When you no longer need the environments:

Delete sandbox: npx ampx sandbox delete
Delete production: aws amplify delete-app --app-id <your-app-id> or remove the app from the AWS Amplify Console

AWS CDK Community Update: Jan/Feb 2026!

Praneeta Prakash — Tue, 17 Feb 2026 20:20:33 +0000

What's New

Hello! So excited to get the regular blogpost updates on AWS CDK going for 2026! This update covers CDK updates from December 2025 through February 2026. The community delivered 150+ pull requests spanning EKS, Bedrock, ECS, and 15+ other AWS services. Whether you're new to CDK or a seasoned user, you'll find new capabilities that make infrastructure as code more powerful and easier to maintain.

Community at a Glance

150+ pull requests merged from external contributors
25+ first-time contributors joined the project
17 top contributors driving major features
Active development across EKS, Bedrock, ECS, and 15+ other services

Upgrade Now

npm install -g aws-cdk@latest

TL;DR

Top features to try this week:
CDK Mixins (Preview): Add capabilities to constructs without rebuilding them link
Kiro Power for AWS IaC: AI-powered CDK and CloudFormation development assistance link
ECS Deployments: Built-in Linear/Canary strategies for safer rollouts link
CloudWatch Logs: Deletion protection prevents accidental data loss link
EKS Hybrid Nodes: Integrate on-premises infrastructure with EKS clusters link
Bedrock AgentCore: API Gateway integration and episodic memory for AI agents link
Also new: Glue typed partition projection, Synthetics Playwright 5.0, RDS enhanced metrics

Major Features

CDK Mixins (Preview) - Add Features to Any Construct

Mixins let you compose functionality onto existing constructs. Think of them as reusable "add-ons" that can be applied to any compatible construct. This means that you don't need to wait for a property to be supported in L2 constructs anymore. For example, using an unsupported AnalyticsConfigurationProperty on S3 L2 construct, becomes simple with the CfnBucketPropsMixin.

const l2bucket = new s3.Bucket(this, 'L2 Bucket')
      .with(new CfnBucketPropsMixin({
        analyticsConfigurations: [{
            id: 'my-analytics',
            storageClassAnalysis: {
                dataExport: {
                    destination: {....},
                }
            }
        }]
    }))

Try it: npm install @aws-cdk/mixins-preview - Read the docs
Note: Preview feature API may change. Currently TypeScript/JavaScript only.
Read blogpost about CDK Mixins

Amazon EKS Enhancements

The EKS module received significant love this quarter with multiple community-driven improvements:
EKS Hybrid Nodes Support You can now seamlessly integrate on-premises and edge infrastructure with your EKS clusters. This opens up hybrid cloud architectures with consistent Kubernetes management.
Native OIDC Provider We've introduced OidcProviderNative using L1 constructs, providing a more efficient alternative to the custom resource-based OpenIdConnectProvider. This improves deployment speed and reduces complexity.
New Access Entry Types Support for EC2, HYBRID_LINUX, and HYPERPOD_LINUX access entry types gives you more granular control over cluster access patterns.

declare const cluster: eks.Cluster;
declare const nodeRole: iam.Role;

// Grant access with EC2 type for Auto Mode node role
cluster.grantAccess('nodeAccess', nodeRole.roleArn, [
  eks.AccessPolicy.fromAccessPolicyName('AmazonEKSAutoNodePolicy', {
    accessScopeType: eks.AccessScopeType.CLUSTER,
  }),
], { accessEntryType: eks.AccessEntryType.EC2 });
});

Bedrock AgentCore Expansion

Thanks to Dinesh Sajwan and Yuki Matsuda, Bedrock AgentCore received powerful new capabilities:
API Gateway Target Support Integrate your AgentCore gateways directly with API Gateway, enabling more flexible routing and integration patterns.
Gateway Interceptors Add custom logic to intercept and transform requests/responses flowing through your AgentCore gateways.
Episodic Memory Strategy Implement sophisticated memory patterns for your AI agents, allowing them to maintain context across interactions.
Read more in the Bedrock AgentCore module documentation

ECS Deployment Strategies

Yuki Matsuda contributed builtin support for Linear and Canary deployment strategies in ECS. These strategies reduce risk when rolling out changes by gradually shifting traffic to new versions.

declare const cluster: ecs.Cluster;
declare const taskDefinition: ecs.TaskDefinition;
declare const blueTargetGroup: elbv2.ApplicationTargetGroup;
declare const greenTargetGroup: elbv2.ApplicationTargetGroup;
declare const prodListenerRule: elbv2.ApplicationListenerRule;

const service = new ecs.FargateService(this, 'Service', {
  cluster,
  taskDefinition,
  deploymentStrategy: ecs.DeploymentStrategy.LINEAR,
  linearConfiguration: {
    stepPercent: 10.0,
    stepBakeTime: Duration.minutes(5),
  },
});

const target = service.loadBalancerTarget({
  containerName: 'web',
  containerPort: 80,
  alternateTarget: new ecs.AlternateTarget('AlternateTarget', {
    alternateTargetGroup: greenTargetGroup,
    productionListener: ecs.ListenerRuleConfiguration.applicationListenerRule(prodListenerRule),
  }),
});

target.attachToApplicationTargetGroup(blueTargetGroup);

Spot Instance Support David Glaser added capacityOptionType to ManagedInstancesCapacityProvider, enabling costeffective Spot instance usage for your ECS workloads.
Read more in the ECS module documentation

AWS Glue Typed Partition Projection

Kazuho CryerShinozuka introduced typed partition projection for Glue tables, bringing type safety to your data catalog definitions:

declare const myDatabase: glue.Database;
new glue.S3Table(this, 'MyTable', {
  database: myDatabase,
  columns: [{
    name: 'data',
    type: glue.Schema.STRING,
  }],
  partitionKeys: [{
    name: 'date',
    type: glue.Schema.STRING,
  }],
  dataFormat: glue.DataFormat.JSON,
  partitionProjection: {
    date: glue.PartitionProjectionConfiguration.date({
      min: '2020-01-01',
      max: '2023-12-31',
      format: 'yyyy-MM-dd',
      interval: 1,  // optional, defaults to 1
      intervalUnit: glue.DateIntervalUnit.DAYS,  // optional: YEARS, MONTHS, WEEKS, DAYS, HOURS, MINUTES, SECONDS
    }),
  },
});

RDS Enhancements

Enhanced Metrics Jasdeep Singh Bhalla added Read/Write IOPS metrics to DatabaseInstance and Volume Read/Write IOPS metrics to DatabaseCluster, giving you better visibility into database performance.
RDS Proxy Auth Scheme Yuki Matsuda added support for default authentication schemes in RDS Proxy, simplifying proxy configuration.
Read more in the RDS module documentation

CloudWatch Logs Deletion Protection

Robert Hanuschke contributed deletion protection configuration for CloudWatch Log Groups. This prevents accidental data loss by blocking log group deletion until protection is explicitly disabled.

new logs.LogGroup(this, 'LogGroup', {
  deletionProtectionEnabled: true,
});

EC2 VPC Flow Logs to Firehose

Tietew added support for using Firehose IDeliveryStreamRef as a flow log destination, enabling realtime log streaming and transformation.

API Gateway v2 EventBridge Integration

Jasdeep Singh Bhalla added PutEvents support for EventBridge integration in API Gateway v2, making eventdriven architectures even easier to build.

Kiro Power for AWS Infrastructure as Code

The challenge: CDK and CloudFormation development requires constantly referencing documentation, understanding best practices, validating templates, and troubleshooting deployments.

The solution: Kiro's AWS Infrastructure as Code Power provides AI-powered assistance for CDK and CloudFormation development. It dynamically loads specialized tools and context only when needed, avoiding MCP context overload.

What it does:

Latest Documentation Access: Search CDK docs, API references, and CloudFormation specs
Code Generation: Generate well-architected infrastructure following AWS best practices
Template Validation: Check CloudFormation templates for errors and compliance issues
Deployment Troubleshooting: Analyze CloudTrail logs and diagnose deployment failures
Best Practices: Apply CDK-NAG rules and security configurations automatically

Try it: Install the power in Kiro and activate it when working on infrastructure code. The power uses the AWS IaC MCP Server under the hood, providing the same capabilities with better context management.

Learn more about Kiro Powers

More Features

Additional improvements this quarter:
Hotswap Support for Bedrock AgentCore
Kenta Goto added hotswap support for AWS::BedrockAgentCore::Runtime, enabling faster development iterations.
EC2 VPC Flow Logs to Firehose (Tietew) - Real-time log streaming and transformation
API Gateway v2 EventBridge Integration (Jasdeep Singh Bhalla) - PutEvents support for event-driven architectures
SageMaker Health Check Timeout (Сергей) - More control over endpoint health checks
IoT Actions HTTP Batching (Kazuho Cryer-Shinozuka) - Improved efficiency for high-volume IoT workloads
Step Functions JSONata Support (Y.Nakamura) - Dynamic control over parallel execution

Community Highlights

Top External Contributors

We want to give a special shoutout to our most active external contributors this quarter:
Yuki Matsuda (mazyu36) - ECS deployment strategies, RDS Proxy auth, Bedrock AgentCore improvements, and EventScheduler fixes
Jasdeep Singh Bhalla - RDS metrics, ECS log driver options, and API Gateway v2 EventBridge integration
Kazuho Cryer-Shinozuka - Glue typed partition projection, IoT Actions batching, and Redshift improvements
Kenta Goto (go-to-k) - Mixins preview improvements and documentation fixes, hotswap on AgentCore
Tietew - EC2 Flow Logs Firehose destination support
yatakemi - Synthetics Playwright runtimes

Get Involved

The AWS CDK is powered by the AWS developer community. Here's how to contribute:

Join cdk.dev on Slack and introduce yourself
Try the CDK Workshop Video Series or Hands-on session
Pick a good first issue - we'll help you through it

Ongoing

Answer questions: Help others on Stack Overflow
Share your work: Publish constructs to Construct Hub
Report bugs: Open an issue with reproduction steps
Stay updated: Star the aws-cdk repo for release notifications Join our quarterly community meetings (videos available here)

Community Showcase

The CDK community continues to build, share, and teach. Here's how developers are using CDK in production and contributing back:

Learning & Best Practices

Manage IAM Policies Manually - Kenta Goto: Prevent CDK from automatically updating IAM role policies when you need full control
AIPowered CDK Development with Kiro - Nao San: Generate CDK code with latest best practices using AI assistance
Build a Serverless Website from Scratch - Dixit Rathod: 4 part tutorial: S3 hosting, API Gateway, DynamoDB, full integration

Monitoring & Operations

One Alarm for Many Resources - Johannes Konings: Use CloudWatch Metrics Insights to monitor 100 resources with one alarm instead of 100
Tag Log Buckets for Security Scanners - Johannes Konings: Make cdknag work with third-party security tools through tagging
Faster AgentCore Deployments - Kenta Goto: Skip CloudFormation for faster AI agent development cycles

Infrastructure Patterns

CDK Terrain Announcement Open Constructs Foundation has announced a community-driven continuation of the Cloud Development Kit for Terraform (CDKTF), with the new name of CDK Terrain.
Workflow Automation on ECS - Vu Dao: Deploy N8N workflow platform with Fargate, RDS, and ElastiCache
A/B Testing at the Edge - Kihara Takuya: Switch between S3 origins using CloudFront Functions for experimentation
Remote Access with Client VPN - Andrew Dunn: Set up secure VPN access to private AWS resources
Deploy TanStack Start Serverless - Johannes Konings: Full-stack React framework on Lambda with API Gateway streaming
Customize CDK Bootstrap - Johannes Konings: Add encryption and access logging to CDK staging bucket

Developer Tools

Self-Hosted GitHub Actions Runners - Amir Szekely (CloudSnorkel): Ephemeral runners on EC2, Fargate, Lambda, CodeBuild, or ECS
Parallel Lambda Bundling Marko (ServerlessLife): Bundle all Lambda functions at once instead of sequentially
Cost Analysis in Pull Requests - towardsthecloud: See AWS cost impact before merging infrastructure changes
Clean Up CDK Assets - Kenta Goto: Remove unused assets and Docker images from cdk.out directory
Visualize CDK Applications - Analyze and understand CDK app structure

AI & Advanced Use Cases

Build AI Agents with AgentCore - Martin Mueller Local development to cloud deployment for Bedrock AI agents
Custom Cognito Email Flows - Lee Gilmore Customize authentication emails with Lambda triggers

Video Content

CDK Development Workflows Practical development techniques and patterns
Advanced CDK Patterns Deep dive into CDK architecture

Thank You!

A huge thank you to everyone who contributed this quarter. Whether you submitted code, reported bugs, answered questions, or shared your knowledge you're making infrastructure as code better for everyone.
Special recognition to our top external contributors who drove major features and fixes. Your work impacts thousands of CDK users worldwide.
We're excited to see what the community builds next. Happy coding!

re:Invent Special Update from AWS CDK

Praneeta Prakash — Wed, 10 Dec 2025 18:22:15 +0000

Index

TL;DR
A Message of Gratitude
Major Features
CDK Mixins - Developer Preview
AI-Powered Development
Service L2 Constructs
Community Highlights
Community Meetings
Community Generated Content
Content from AWS
How Can You Be Involved

TL;DR

As we close out 2025, we're filled with gratitude for our incredible CDK community! This year brought exciting updates: CDK Mixins in developer preview, the AWS IaC MCP Server for AI-powered assistance, comprehensive EC2 Image Builder L2 support, Bedrock AgentCore constructs, and powerful new patterns like L1 constructs accepting other constructs as parameters. We've seen amazing contributions from our community (both internal AWS and external), launched new Grants patterns, added L2 constructs for Lambda Managed Instances, Lambda durable functions, Lambda multi-tenancy, Route53 failover routing, DynamoDB compound keys for GSIs, VPC Endpoints for ACM/ACM-PCA, and so much more. Thank you for making CDK better every day!

A Message of Gratitude

As we wrap up 2025, we want to take a moment to thank our amazing CDK community. This year has been extraordinary—not just because of the features we've shipped, but because of the incredible people who make CDK what it is.

To our external contributors: You've submitted PRs, filed issues, answered questions, and built amazing things with CDK. Your contributions—from major L2 constructs to small bug fixes—make CDK better for everyone. Thank you for your time, expertise, and dedication.

To our community members: Whether you're asking questions on Stack Overflow, sharing knowledge on Slack, or helping others in GitHub Discussions, you're building the welcoming, collaborative community that makes CDK special.

As we head into the holidays, we're grateful for each of you. Here's to an amazing 2026! 🎄✨

Major Features

CDK Mixins - Developer Preview

CDK Mixins fundamentally transform how you compose and reuse infrastructure abstractions. Apply sophisticated features to any construct—L1, L2, or custom—without being locked into specific implementations.

import { Mixins } from '@aws-cdk/mixins-preview';
import '@aws-cdk/mixins-preview/with';
import { EncryptionAtRest, AutoDeleteObjects } from '@aws-cdk/mixins-preview/aws-s3/mixins';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as logs from 'aws-cdk-lib/aws-logs';

// Fluent syntax
const bucket = new s3.CfnBucket(this, 'Bucket')
  .with(new EncryptionAtRest())
  .with(new AutoDeleteObjects());

// Cross-service abstractions
const logGroup = new logs.CfnLogGroup(this, 'LogGroup');
Mixins.of(logGroup).apply(new EncryptionAtRest());

// Apply at scale
Mixins.of(this).apply(new EncryptionAtRest());

Vended Log Deliveries - Automatically configure log delivery for 47+ AWS resources:

import { LogDelivery } from '@aws-cdk/mixins-preview';

// Automatically configure S3 bucket logging
const bucket = new s3.CfnBucket(this, 'Bucket');
Mixins.of(bucket).apply(new LogDelivery());

EventBridge Event Patterns

Helpers to generate type-safe EventBridge event patterns for 26 services:

import { BucketEvents } from '@aws-cdk/mixins-preview/aws-s3/events';
import * as events from 'aws-cdk-lib/aws-events';
import * as targets from 'aws-cdk-lib/aws-events-targets';

// Works with L2 constructs
const bucket = new s3.Bucket(this, 'Bucket');
const bucketEvents = BucketEvents.fromBucket(bucket);

new events.Rule(this, 'Rule', {
  eventPattern: bucketEvents.objectCreatedPattern({
    object: { key: ['uploads/*'] },
  }),
  targets: [new targets.LambdaFunction(fn)],
});

// Also works with L1 constructs
const cfnBucket = new s3.CfnBucket(this, 'CfnBucket');
const cfnBucketEvents = BucketEvents.fromBucket(cfnBucket);

new events.CfnRule(this, 'CfnRule', {
  state: 'ENABLED',
  eventPattern: cfnBucketEvents.objectCreatedPattern(),
  targets: [{ arn: fn.functionArn, id: 'Target' }],
});

New Grants Pattern

Simplified permission management with dedicated grant classes! Now available for S3, DynamoDB, Step Functions, and Route53.

// S3
bucket.grants.read(role);
bucket.grants.write(role);

// DynamoDB
table.grants.readData(role);
table.grants.writeData(role);
table.streamGrants.read(role);

// Step Functions
stateMachine.grants.startExecution(role);
stateMachine.grants.read(role);

// Route53
hostedZone.grants.delegation(role);

Get started: npm install @aws-cdk/mixins-preview

L1 Constructs Accept Constructs as Parameters

Major DX improvement! Pass constructs directly instead of extracting ARNs/IDs for known resource relationships.

// Before
new lambda.CfnFunction(this, 'Function', {
  role: role.roleArn,  // Manual extraction
});

// After
new lambda.CfnFunction(this, 'Function', {
  role: role,  // Pass construct directly!
});

This pattern works across all L1 constructs, making your code cleaner and more intuitive.

AI-Powered Development

AWS IaC MCP Server

The AWS IaC MCP Server brings Model Context Protocol to your CDK workflow, integrating with AI assistants like Amazon Q Developer, Claude Desktop, Cursor, and VS Code.

Features:

Build CDK with latest documentation, API references, and best practices
Find CDK code samples across TypeScript, Python, Java, C#, Go
Validate CloudFormation templates with cfn-lint
Check compliance with cfn-guard
Troubleshoot deployments with pattern matching

Configuration (~/.aws/amazonq/mcp.json):

{
  "mcpServers": {
    "awslabs.aws-iac-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.aws-iac-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "your-named-profile"
      }
    }
  }
}

Documentation

Service L2 Constructs

EC2 Image Builder (Alpha)

Comprehensive L2 support for EC2 Image Builder with constructs for components, recipes, pipelines, workflows, and lifecycle policies!

import * as imagebuilder from '@aws-cdk/aws-imagebuilder-alpha';

const component = new imagebuilder.Component(this, 'Component', {
  platform: imagebuilder.Platform.LINUX,
  data: imagebuilder.ComponentData.fromAsset(this, 'ComponentAsset', 'component.yaml'),
});

const recipe = new imagebuilder.ImageRecipe(this, 'Recipe', {
  parentImage: 'ami-12345678',
  components: [component],
});

const pipeline = new imagebuilder.ImagePipeline(this, 'Pipeline', {
  imageRecipe: recipe,
  infrastructureConfiguration,
  schedule: imagebuilder.Schedule.cron({ hour: '0', minute: '0' }),
});

const lifecycle = new imagebuilder.LifecyclePolicy(this, 'Lifecycle', {
  resources: [imagebuilder.LifecycleResource.AMI],
  rules: [{
    action: imagebuilder.LifecycleAction.DELETE,
    selection: {
      type: imagebuilder.SelectionType.AGE,
      value: 90,
      unit: imagebuilder.TimeUnit.DAYS,
    },
  }],
});

Bedrock AgentCore (Alpha)

Build complete AI agents with runtime, gateway, memory, and tool integrations!

Runtime - Container-based agent execution with ECR and image URI support:

import * as agentcore from '@aws-cdk/aws-bedrock-agentcore-alpha';

// From ECR repository
const runtime = new agentcore.Runtime(this, 'Runtime', {
  runtimeName: 'my-agent-runtime',
  agentRuntimeArtifact: agentcore.AgentRuntimeArtifact.fromEcrRepository(repository, 'v1.0.0'),
});

// From image URI
const runtime2 = new agentcore.Runtime(this, 'Runtime2', {
  runtimeName: 'my-agent-runtime-2',
  agentRuntimeArtifact: agentcore.AgentRuntimeArtifact.fromImageUri('123456789012.dkr.ecr.us-east-1.amazonaws.com/my-image:latest'),
});

Gateway - Tool integrations with Lambda, OpenAPI, Smithy, and MCP servers:

const gateway = new agentcore.Gateway(this, 'Gateway', {
  gatewayName: 'my-gateway',
});

// Add Lambda target
gateway.addLambdaTarget('LambdaTarget', {
  gatewayTargetName: 'my-lambda-target',
  lambdaFunction: myFunction,
  toolSchema: agentcore.ToolSchema.fromAsset('schema.json'),
});

// Add MCP server target
gateway.addMcpServerTarget('McpTarget', {
  gatewayTargetName: 'my-mcp-server',
  endpoint: 'https://my-mcp-server.example.com',
});

Memory, Browser & Code Interpreter:

const memory = new agentcore.Memory(this, 'Memory', {
  memoryName: 'conversation-memory',
});

const browser = new agentcore.Browser(this, 'Browser', {
  browserName: 'my-browser',
});

const codeInterpreter = new agentcore.CodeInterpreter(this, 'CodeInterpreter', {
  codeInterpreterName: 'my-code-interpreter',
});

Lambda Updates

Lambda Managed Instances - Managed instances for predictable performance:

import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as ec2 from 'aws-cdk-lib/aws-ec2';

// Create VPC and security group (required)
const vpc = new ec2.Vpc(this, 'MyVpc');
const securityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', { vpc });

// Create capacity provider with scaling configuration
const capacityProvider = new lambda.CapacityProvider(this, 'MyCapacityProvider', {
  capacityProviderName: 'my-capacity-provider',
  subnets: vpc.privateSubnets,
  securityGroups: [securityGroup],
  scalingOptions: lambda.ScalingOptions.manual([
    lambda.TargetTrackingScalingPolicy.cpuUtilization(70),
  ]),
  instanceTypeFilter: lambda.InstanceTypeFilter.allow([
    ec2.InstanceType.of(ec2.InstanceClass.M5, ec2.InstanceSize.LARGE),
  ]),
});

// Create function (runtime must be NODEJS_22_X or newer)
const fn = new lambda.Function(this, 'Function', {
  runtime: lambda.Runtime.NODEJS_22_X,
  handler: 'index.handler',
  code: lambda.Code.fromAsset('lambda'),
});

// Associate function with capacity provider
capacityProvider.addFunction(fn, {
  perExecutionEnvironmentMaxConcurrency: 10,
  executionEnvironmentMemoryGiBPerVCpu: 4,
});

Pre-provision managed instances for consistent performance and reduced cold starts. Perfect for latency-sensitive workloads that need predictable execution times. Read the blogpost to learn more.

Durable Functions - Build stateful Lambda functions that can pause and resume execution:

const fn = new lambda.Function(this, 'DurableFunction', {
  runtime: lambda.Runtime.NODEJS_24_X,
  handler: 'index.handler',
  code: lambda.Code.fromAsset('lambda'),
  durableConfig: {
    executionTimeout: Duration.hours(1),
    retentionPeriod: Duration.days(30),
  },
});

Durable functions automatically get the AWSLambdaBasicDurableExecutionRolePolicy with permissions for lambda:CheckpointDurableExecution and lambda:GetDurableExecutionState.

Multi-Tenancy Support:

const fn = new lambda.Function(this, 'Function', {
  runtime: lambda.Runtime.NODEJS_24_X,
  handler: 'index.handler',
  code: lambda.Code.fromAsset('lambda'),
  tenancyConfig: {
    tenancyMode: lambda.TenancyMode.DEDICATED,
  },
});

ESM Features - Support for ES modules with improved error handling and observability.

New Runtimes:

Node.js 24.x
Python 3.14
Java 25

DynamoDB Compound Keys for Global Secondary Indexes

table.addGlobalSecondaryIndex({
  indexName: 'gsi1',
  partitionKey: { name: 'gsi1pk', type: dynamodb.AttributeType.STRING },
  sortKey: { name: 'gsi1sk', type: dynamodb.AttributeType.STRING },
  projectionType: dynamodb.ProjectionType.ALL,
});

Additional Construct Updates

Route53 - Failover routing policy support:

import * as route53 from 'aws-cdk-lib/aws-route53';

new route53.ARecord(this, 'PrimaryRecord', {
  zone: hostedZone,
  recordName: 'www',
  target: route53.RecordTarget.fromIpAddresses('1.2.3.4'),
  failover: route53.Failover.PRIMARY,
  healthCheck: primaryHealthCheck,
  setIdentifier: 'failover-primary',
});

new route53.ARecord(this, 'SecondaryRecord', {
  zone: hostedZone,
  recordName: 'www',
  target: route53.RecordTarget.fromIpAddresses('5.6.7.8'),
  failover: route53.Failover.SECONDARY,
  setIdentifier: 'failover-secondary',
});

Build highly available DNS configurations with automatic failover between primary and secondary endpoints.

Contributed by: Dave Dennis

EC2 - VPC Endpoints for ACM and ACM-PCA:

import * as ec2 from 'aws-cdk-lib/aws-ec2';

const acmEndpoint = new ec2.InterfaceVpcEndpoint(this, 'AcmEndpoint', {
  vpc,
  service: ec2.InterfaceVpcEndpointAwsService.CERTIFICATE_MANAGER,
});

const acmPcaEndpoint = new ec2.InterfaceVpcEndpoint(this, 'AcmPcaEndpoint', {
  vpc,
  service: ec2.InterfaceVpcEndpointAwsService.PRIVATE_CERTIFICATE_AUTHORITY,
});

Enable private connectivity to certificate services without internet gateway routing.

Contributed by: Yuto Anada

API Gateway - Response streaming support:

import * as apigateway from 'aws-cdk-lib/aws-apigateway';
const api = new apigateway.RestApi(this, 'StreamingApi', {
  description: "'API with streaming responses',"
});
const integration = new apigateway.LambdaIntegration(streamingFunction, {
  responseTransferMode: apigateway.ResponseTransferMode.STREAM,
});
api.root.addMethod('GET', integration);

Stream large responses from Lambda functions through API Gateway for better performance.

Contributed by: Kenta Goto

RDS - Enhanced CloudWatch log exports:

import * as rds from 'aws-cdk-lib/aws-rds';

const instance = new rds.DatabaseInstance(this, 'Database', {
  engine: rds.DatabaseInstanceEngine.mysql({
    version: rds.MysqlEngineVersion.VER_8_0,
  }),
  cloudwatchLogsExports: ['error', 'general', 'slow-query', 'iam-db-auth-error'],
  instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MICRO),
  vpc,
});

Improved observability with automatic export of IAM database authentication errors to CloudWatch.

Contributed by: Sami Jaktholm

Step Functions - Multiline JSONata string support:

import * as stepfunctions from 'aws-cdk-lib/aws-stepfunctions';

const transformTask = new stepfunctions.Pass(this, 'Transform', {
  parameters: {
    'TransformedData.$': `
      $merge([
        $,
        {
          "timestamp": $now(),
          "processed": true
        }
      ])
    `,
  },
});

Write complex JSONata transformations across multiple lines for better readability.

Contributed by: Mathieu Gilbert

EC2 - Instance metadata configuration:

import * as ec2 from 'aws-cdk-lib/aws-ec2';

const instance = new ec2.Instance(this, 'Instance', {
  instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MICRO),
  machineImage: ec2.MachineImage.latestAmazonLinux2(),
  vpc,
  requireImdsv2: true, // Enforce IMDSv2 for security
  httpTokens: ec2.HttpTokens.REQUIRED,
  httpPutResponseHopLimit: 1,
});

Enhanced security controls for EC2 instance metadata service configuration.

Contributed by: Pahud Hsieh

Glue - Version 5.1 support:

import * as glue from 'aws-cdk-lib/aws-glue';

const job = new glue.Job(this, 'EtlJob', {
  executable: glue.JobExecutable.pythonEtl({
    glueVersion: glue.GlueVersion.V5_1,
    pythonVersion: glue.PythonVersion.THREE_NINE,
    script: glue.Code.fromAsset('scripts/etl.py'),
  }),
  workerType: glue.WorkerType.G_2X,
  workerCount: 10,
});

Latest Glue runtime with improved performance and new features for data processing workflows.

Contributed by: Yuki Matsuda

Community Highlights

Here are our most active external contributors this year:

Contributor	First Contribution	Latest Contribution	Days Active	Repositories
Yuki Matsuda	May 1, 2024	Nov 26, 2025	574	aws/aws-cdk
Kazuho Cryer-Shinozuka	Dec 1, 2023	Nov 28, 2025	727	aws/aws-cdk
Kenta Goto	Sep 27, 2023	Nov 25, 2025	790	aws/aws-cdk, aws/aws-cdk-cli
Hung Tran	Nov 9, 2024	Nov 26, 2025	382	aws/aws-cdk
Michael Sambol	Oct 27, 2023	Jun 1, 2025	583	aws/aws-cdk
Tietew	Dec 25, 2023	Nov 12, 2025	687	aws/aws-cdk, aws/aws-cdk-cli

*March 2025* was our most active external contribution month with over *200 unique active members* from the community! 🚀

Community Generated Content

We saw some amazing projects and blogposts created by CDK users to help others learn and improve their CDK skills.

Contributor	Link
Kenta Goto	AWS CDK Unit Testing Advanced Tips: Aligning Feature Flags and Skipping Bundling
Kenta Goto	AWS CDK Introduces Mixins: A Major Feature for Flexible Construct Composition (Developer Preview)
azmimengu	AWS CDK N8N Self-Hosted Infrastructure
Vu Dao	ClamAV (Anti-Virus) as a REST application on AWS ECS

Community Meetings

We held two community meetings so far! Join us on the CDK.dev YouTube channel to watch recordings and follow the community-meetings channel on CDK Slack stay updated on upcoming meetings. The next community meeting will be in January.

Content from AWS

Helpful Resources:

AWS IaC MCP Server speed up CDK development with AI assistance.
AWS CDK API Reference
CDK Workshop Get started on CDK with hands-on learning.
AWS Solution Constructs contains popular L3 constructs from AWS experts.
CDK Construct Hub Discover community built constructs.

How Can You Be Involved

Report Issues

Open an issue on GitHub.

Contribute Code

Check our contributing guide and look for good first issue or help wanted labels.

Join the Conversation

Slack: CDK.dev community
GitHub: Discussions
Stack Overflow: aws-cdk tag

Star the Repo

Give us a star on GitHub! ⭐

Happy Holidays from the CDK Team!

As we close out 2025, we're incredibly grateful for this amazing community. Whether you contributed code, answered questions, filed issues, or simply built cool things with CDK—thank you for being part of our journey.

Here's to an even more amazing 2026! May your deployments be successful and your stacks always converge.

Building fullstack Amplify applications with the new AWS MCP

Praneeta Prakash — Fri, 05 Dec 2025 16:01:53 +0000

by Galib Sarayev

AWS has announced AWS MCP with additional Standard Operational Procedures (SOPs) that helps frontend developers to design, build, and deploy fullstack applications with AWS Amplify. Instead of manually piecing together guidance from documentation, examples, forum posts, trial-and-error or best practices, Amplify developers can now rely on an MCP-powered workflow that provides structured, high-quality guidance for fullstack Amplify development.

Amplify is a proven service that makes building cloud-connected apps much easier for frontend and fullstack developers. It offers clear, high-level tools that simplify both the backend and the frontend implementation. On the backend, features like authentication, APIs, storage, and serverless functions can be defined declaratively. On the frontend, Amplify integrates smoothly with popular frameworks like React, Next.js, and React Native. The new agentic experience provided by AWS MCP builds on this foundation by adding an agent-ready layer of structured guidance that developers can use directly inside AI tools.

Instead of generating arbitrary advice, agents equipped with AWS MCP now follow curated Standard Operating Procedures (SOPs) that reflect established Amplify best practices. These SOPs capture recommended patterns for backend setup, frontend integration, and deployment workflows. The result is output that is not only functional but aligned with the way Amplify is intended to be used.

Fullstack Guidance Through SOPs

The AWS MCP offers several Amplify-specific SOPs that guide the agents through the lifecycle of building and deploying an application with Amplify:

amplify-backend-implementation
Helps the agent implement well-structured backend applications using Amplify's capabilities such as Auth, Data, Storage, and Functions etc. It promotes recommended patterns, secure defaults, and idiomatic use of Amplify's backend abstractions.

amplify-frontend-integration
Guides integration of the Amplify backend with modern JavaScript and TypeScript frameworks. This includes state management recommendations, data binding patterns, and configuration best practices using the Amplify libraries.

amplify-deployment-guide
Walks the agent through deploying the application using Amplify. It covers branch-based workflows, CI/CD configuration, environment setup, and operational guardrails.

These SOPs ensure the agent does not simply generate code but produces code that aligns with Amplify's design principles.

Curated, Agent-Optimized Documentation

In addition to SOPs, the AWS MCP includes curated Amplify documentation that has been optimized for retrieval and consumption by agents. Rather than relying on generic search results or unstructured pages, agents can now query well-organized, purpose-built instructional materials.

This curated content allows agents to provide more precise implementation details, produce fewer incorrect assumptions, and reference supported patterns. Developers benefit from clearer explanations, more robust examples, and recommendations that correspond to the current Amplify ecosystem.

What This Enables

You can now:

Generate consistent fullstack Amplify project scaffolds aligned with best practices
Get detailed and up-to-date backend guidance including Auth, Storage, APIs, Functions etc.
Receive frontend integration steps for frameworks such as React, Vue.js, Angular, Next.js etc.
Implement secure deployment flows using environment-aware Amplify Hosting
Ask architectural questions and get answers that reflect recommended Amplify usage
Accelerate prototyping and reduce implementation errors

Getting Started

Prerequisites

Note: You can see the whole list of prerequisites in the MCP's official documentation.

Before setting up the AWS MCP Server, make sure you have the following:

Core Requirements

Python 3.10+ installed on your machine
uv package manager installed
AWS credentials configured locally (via aws configure, SSO, or environment variables)
An MCP-compatible AI client (e.g., Kiro CLI, Claude Desktop, etc.)

IAM Permissions (Required if you're not using an Administrator role)

Note: Skip this section if your AWS credentials already use an Administrator role.

If you're using a non-admin IAM user or role, you must explicitly grant permissions for AWS MCP Server operations.

To configure IAM permissions:

Open the IAM console: https://console.aws.amazon.com/iam/
Select the user or role associated with your AWS credentials
Attach the following IAM policy:

{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Action":[
            "aws-mcp:InvokeMCP",
            "aws-mcp:CallReadOnlyTool",
            "aws-mcp:CallReadWriteTool"
         ],
         "Resource":"*"
      }
   ]
}

Additional Credential Requirements for Amplify

To deploy Amplify Gen 2 sandbox environments, your credentials must include permissions equivalent to the AmplifyBackendDeployFullAccess AWS-managed policy.
To create or manage Amplify applications and deploy Amplify Gen 2 backends, use credentials with the AdministratorAccess-Amplify AWS-managed policy.

Configuration

Configure the MCP server in your MCP client configuration. For this blog we will focus on Kiro CLI. Edit .kiro/settings/mcp.json:

{
  "mcpServers": {
    "aws-mcp": {
      "command": "uvx",
      "timeout": 100000,
      "transport": "stdio",
      "args": [
        "mcp-proxy-for-aws@latest",
        "https://aws-mcp.us-east-1.api.aws/mcp",
        "--metadata", "AWS_REGION=us-west-2"
      ]
    }
  }
}

Replace us-west-2 with your preferred default AWS Region. If you do not provide a region as metadata, operations default to us-east-1.

You can see the full set up guide in the official AWS MCP documentation.

Example Use Case With Kiro CLI

In this example, we'll build a fullstack React application using an Amplify Gen 2 backend and the Amplify JavaScript and UI libraries with the help of AWS MCP.

Step 1: In your terminal, run kiro-cli chat to start using Kiro CLI and run /tools to check the tools from AWS MCP are available.

Step 2: Prompt the agent to implement backend for your application. Allow the SOP to execute aws___retrieve_agent_sop tool to retrieve amplify-backend-implementation SOP.

Step 3: Prompt the agent to implement frontend for the application and integrate it with the already implemented backend using Amplify libraries. In case agent asks, allow it to execute aws___retrieve_agent_sop tool to retrieve amplify-frontend-integration SOP.

Step 4: Ask agent to deploy the Amplify backend as sandbox for the testing purposes. Observe the agent executing aws___retrieve_agent_sop tool to retrieve amplify-deployment-guide SOP (in case agent asks, allow it to execute the tool).

The agent will follow the deployment guide, deploy the backend as a sandbox environment, and generate amplify_outputs.json to connect the frontend to the deployed backend.

Step 5: Start the frontend locally, and see the integration with Amplify backend. Continue iterating on the application.

Step 6: If satisfied with the final state of the application, ask the agent to deploy the application to production and set up CI/CD for it using Amplify Hosting.

The agent will go through the deployment guide and:

Verify required dependencies are installed
Verify project structure
Set up a git repository
Create a new Amplify app
Connect the amplify to the git repository created for the CI/CD deployment
Push changes to the git
Start and monitor deployment, if the deployment fails, agent will troubleshoot it for you and fix accordingly

Step 7: When you need to search for knowledge about Amplify, the agent can use the search_documentation with amplify as topic filter.

Step 8: When you no longer need the environments you created, clean them up to avoid unnecessary costs:

To delete the sandbox environment, run npx ampx sandbox delete following the Amplify documentation, or delete the sandbox directly from the AWS Console.
To delete the production deployment, run aws amplify delete-app --app-id <your-app-id> via the AWS CLI, or remove the application from the AWS Console.

Conclusion

The introduction of AWS MCP support for Amplify marks a meaningful step forward in how developers build cloud-connected applications. By combining Amplify's high-level abstractions with structured SOPs and curated documentation, AI tools can now generate applications that are not only functional but aligned with recommended patterns. This reduces friction, accelerates development, and improves the reliability of AI-assisted workflows. Whether you are experimenting with new ideas or building production systems, the Amplify MCP offers a clearer, more consistent path to delivering well-architected fullstack applications on AWS. The new AWS MCP does not replace developer expertise, but it amplifies it—removing friction, reducing misconfigurations, and accelerating how fullstack cloud apps are built.

Announcing AWS CDK Mixins (Preview): Composable Abstractions for AWS Resources

Praneeta Prakash — Fri, 28 Nov 2025 20:46:56 +0000

by Michael Kaiser and Momo Kornher

We are excited to announce the developer preview of CDK Mixins, a new feature of the AWS Cloud Development Kit (CDK) that fundamentally changes how developers compose and reuse infrastructure abstractions. CDK Mixins enable you to apply sophisticated features to any construct whether L1, L2, or custom without being locked into specific implementations. This new mechanism addresses one of the most persistent challenges in infrastructure as code: the tension between comprehensive AWS coverage and sophisticated abstractions.

Background

The AWS Cloud Development Kit (CDK) is an open-source software development framework for defining cloud infrastructure in code and provisioning it through AWS CloudFormation. It contains pre-written modular and reusable cloud components known as constructs. Constructs are the basic building blocks representing one or more AWS CloudFormation resources and their configuration.

Traditionally, CDK constructs are organized into three levels. L1 constructs map directly to CloudFormation resources and provide day-one access to new AWS features. L2 constructs offer higher-level abstractions with convenience methods, security defaults, and helper functions. L3 constructs (also known as patterns) combine multiple resources to solve specific use cases. However, this architecture creates a fundamental trade-off: customers must choose between immediate access to new AWS features (L1) and sophisticated abstractions (L2/L3). Enterprise customers report needing to customize L2 constructs, often rebuilding entire construct libraries to meet their specific requirements.

CDK Mixins solve this problem by decoupling abstractions from construct implementations. Instead of bundling all features into monolithic L2 constructs, Mixins allow you to compose exactly the capabilities you need, apply them to any construct type, and maintain full access to underlying CloudFormation properties.

What are CDK Mixins?

CDK Mixins are composable, reusable abstractions that can be applied to constructs after they are created. Think of them as modular capabilities that you can mix and match to build exactly the infrastructure you need. Unlike traditional L2 constructs that bundle all features together, Mixins give you fine-grained control over which abstractions apply.

Key benefits include:

Universal Compatibility: Apply the same abstractions to L1 constructs, L2 constructs, or custom constructs
Composable Design: Mix and match features without inheriting unwanted behaviors
Cross-Service Abstractions: Create custom mixins that work across different AWS services
Day-One Coverage: Access new AWS features immediately while keeping existing L2 or L3 constructs
Type Safety: Maintain compile-time guarantees and IDE support

Using CDK Mixins

CDK Mixins are available starting in the @aws-cdk/mixins-preview package. They can be used with both L1, L2 and L3 constructs:

// CDK Mixins can be used with L1s
new s3.CfnBucket(stack, "MixinsL1DemoBucket")
  // Use the fluent .with() syntax (only available in JavaScript/TypeScript during preview)
  .with(new s3Mixins.EnableVersioning());

// ... or with L2s
new s3.Bucket(stack, "MixinsL2DemoBucket")
  // Cfn Property Mixins provide type-safe fallbacks for L2s
  // and configuration after initial creation
  .with(new s3Mixins.CfnBucketPropsMixin({
    objectLockEnabled: true,
    objectLockConfiguration: {
      objectLockEnabled: "Enabled",
      rule: {
        defaultRetention: {
          mode: "COMPLIANCE",
          days: 30,
        },
      },
    },
  }));

You can also use Mixins.of() to apply Mixins in other languages or with more control over which constructs receive the mixin:

// Use Mixins.of() to apply Mixins in other languages
// This also gives you more options to apply only to certain constructs
Mixins.of(stack, /* optional */ ConstructSelector.byId(/^MixinsL1DemoBucket$/))
  .apply(new s3Mixins.AutoDeleteObjects());

Apply mixins at scale to entire construct trees or specific resource types:

// Apply your Mixins to the whole app
Mixins.of(app).apply(new MyDataRecovery());
// ... or only to some constructs
Mixins.of(app, ConstructSelector.resourcesOfType(s3.CfnBucket.CFN_RESOURCE_TYPE_NAME)).apply(new MyDataRecovery());

Creating Custom Mixins

Creating your own Mixins is straightforward they are simple classes implementing the Mixin interface. The supports() method determines which constructs the mixin can be applied to, and applyTo() modifies the construct. Here's a custom mixin that enables data recovery features across both S3 buckets and DynamoDB tables:

// It's easy to develop your own Mixins
class MyDataRecovery implements Mixin {
  public supports(construct: IConstruct): boolean {
    // Mixins can be cross-service and support different resources at once
    return construct instanceof s3.CfnBucket || construct instanceof dynamodb.CfnTable;
  }

  public applyTo(construct: IConstruct): IConstruct {
    if (construct instanceof s3.CfnBucket) {
      construct.versioningConfiguration = {
        status: 'Enabled',
      };
    }

    if (construct instanceof dynamodb.CfnTable) {
      construct.pointInTimeRecoverySpecification = {
        pointInTimeRecoveryEnabled: true,
      };
    }
    return construct;
  }
}

Once defined, you can apply your custom mixin to resources:

// ... and to use them:
new s3.Bucket(stack, 'AcmeBucket');
new dynamodb.TableV2(stack, 'AcmeTable', {
  partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
});

// Apply your Mixins to the whole app
Mixins.of(app).apply(new MyDataRecovery());
// ... or only to some constructs
Mixins.of(app, ConstructSelector.resourcesOfType(s3.CfnBucket.CFN_RESOURCE_TYPE_NAME)).apply(new MyDataRecovery());

This pattern enables organizations to create reusable abstractions that work across any construct type, ensuring consistent security and compliance policies throughout their infrastructure.

Mixin Behavior Control

Control whether mixins must successfully apply or can gracefully skip unsupported constructs:

// Mixin application comes in two behavior options:
// Graceful: Skips unsupported constructs
const logGroup = new logs.CfnLogGroup(stack, 'LogGroup');
Mixins.of(logGroup).apply(new s3Mixins.AutoDeleteObjects());

// Strict: Throws if any construct is not supported by the mixin
Mixins.of(logGroup).mustApply(new s3Mixins.AutoDeleteObjects());

This flexibility allows you to choose the right behavior for your use case whether you want to apply Mixins opportunistically or enforce their presence.

Getting Started

CDK Mixins are available in developer preview starting with the @aws-cdk/mixins-preview package. To get started:

Install the package:

npm install --save-dev aws-cdk-lib @aws-cdk/mixins-preview

Import the .with() syntax in your stack file:

// stack.ts
import '@aws-cdk/mixins-preview/with';

Import and use Mixins in your CDK application:

import { Mixins } from '@aws-cdk/mixins-preview/core';

Explore the documentation for detailed examples and API references.

As this is a developer preview, we encourage you to try CDK Mixins in your applications and provide feedback. The APIs may evolve based on community input before reaching general availability.

Conclusion

CDK Mixins represent a fundamental shift in how we think about infrastructure abstractions. By decoupling capabilities from construct implementations, Mixins give you the freedom to compose exactly the infrastructure you need whether you are using L1 constructs for day-one AWS features, L2 constructs for convenience, or custom constructs for enterprise requirements.

We are excited to see what the community builds with CDK Mixins. Share your feedback, create custom Mixins, and help shape the future of infrastructure as code with AWS CDK.

For more information, check out:

CDK Mixins Documentation

AWS CDK Monthly Update - September 2025

Praneeta Prakash — Mon, 13 Oct 2025 15:53:30 +0000

Index

TL;DR
Important Announcements
Major Features
- CDK Refactor
- ECS Managed Instances Capacity Provider
- ElastiCache Serverless L2 Constructs
- DocumentDB Serverless Support
- CodeBuild Fleet Enhancements
- RDS Proxy Endpoints
Community Highlights
- Special Recognition
- Content from the Community
- CDK Express Pipeline GitHub Diff Action
- CDK Booster
- Promptz.dev
- CDK Environment Management Guide
- AWS CDK Tutorial
- ACM Exportable Certificates
Content from AWS
How Can You Be Involved

TL;DR

Here is what AWS CDK team has been up to in September 2025. We're thrilled to introduce CDK Refactor - a game-changing feature that finally lets you reorganize your CDK code while preserving your deployed resources (no more accidental replacements!). We've also expanded our L2 construct library with recent additions for ECS Managed Instances, ElastiCache Serverless, and DocumentDB Serverless, while enhancing CodeBuild with powerful fleet management capabilities. Meanwhile, our amazing community continues to innovate with tools like CDK Express Pipeline GitHub Diff Action for visual PR reviews and CDK Booster for faster Lambda bundling. Let's dive into the details!

Important Announcements

Before diving into the features, here are some important announcements that might affect your CDK projects:

CDK GoLang Library – Upcoming Backward Incompatible Change - Critical update for GoLang CDK users that will require code changes in upcoming releases.
"Class incorrectly implements interface": additional interface member in v2.215.0 - Recent TypeScript interface changes that may affect custom construct implementations.

Major Features

CDK Refactor - Preserve Resources While Refactoring Code

CDK Refactor is now available in preview! This feature solves one of the most anxiety-inducing challenges in CDK development - the fear of accidentally replacing your stateful resources when you're simply trying to clean up your code.

What it solves: In the past, when you renamed constructs or moved resources between stacks, CloudFormation would interpret these changes as "destroy and recreate" operations, potentially leading to data loss or service interruptions. This made refactoring CDK code risky and stressful.

How it works: The new cdk refactor command intelligently detects changes in your construct tree and leverages CloudFormation's refactoring capabilities to update logical IDs without replacing the underlying physical resources. Here's a simple example:

Before
App
└─ MyStack
   ├─ Bucket
   ├─ Distribution
   └─ Function

After
App
├─ WebStack
│  ├─ WebsiteOrigin
│  └─ Distribution
└─ MyStack
   └─ Function

cdk refactor --unstable=refactor

With this capability, you can now confidently:

Rename constructs without worrying about resource replacement
Move resources between stacks as your architecture evolves
Extract reusable components to improve code organization
Apply software engineering best practices safely to your infrastructure code

ECS Managed Instances Capacity Provider

We're happy to announce full L2 construct support for ECS Managed Instances. This capability bridges the gap between serverless simplicity and EC2 flexibility, allowing you to specify exactly which instance types you need for specialized workloads.

Here's how to set it up:

declare const vpc: ec2.Vpc;
declare const infrastructureRole: iam.Role;
declare const instanceProfile: iam.InstanceProfile;
declare const securityGroups: ec2.SecurityGroup[];
declare const taskDefinition: ecs.TaskDefinition;

const cluster = new ecs.Cluster(this, 'Cluster', { vpc });

// Create a Managed Instances Capacity Provider
const miCapacityProvider = new ecs.ManagedInstancesCapacityProvider(this, 'MICapacityProvider', {
  infrastructureRole,
  ec2InstanceProfile: instanceProfile,
  subnets: vpc.privateSubnets,
  securityGroups: securityGroups,
  instanceRequirements: {
    vCpuCountMin: 1,
    memoryMin: Size.gibibytes(2),
    cpuManufacturers: [ec2.CpuManufacturer.INTEL],
    acceleratorManufacturers: [ec2.AcceleratorManufacturer.NVIDIA],
  },
  propagateTags: ecs.PropagateManagedInstancesTags.CAPACITY_PROVIDER,
});

// Add the capacity provider to the cluster
cluster.addManagedInstancesCapacityProvider(miCapacityProvider);

new ecs.Ec2Service(this, 'EC2Service', {
  cluster,
  taskDefinition,
  minHealthyPercent: 100,
  capacityProviderStrategies: [
    {
      capacityProvider: miCapacityProvider.capacityProviderName,
      weight: 1,
    },
  ],
});

ElastiCache Serverless L2 Constructs

Setting up Redis, Valkey or MemCached clusters just got a whole lot easier! We've introduced comprehensive L2 constructs for ElastiCache Serverless in the @aws-cdk/aws-elasticache-alpha package, taking care of all the configuration complexity for you.

declare const vpc: ec2.Vpc;

// Create an IAM user that has only write access
const user = new IamUser(this, 'User', {
  userId: "user",
  engine: UserEngine.REDIS,
  accessControl: AccessControl.fromAccessString('on ~* -@all +@write +ping')
});

// Create default NoPasswordUser, since Redis must have default username
const defaultUserNoAccess = new NoPasswordUser(this, 'DefaultUser', {
  userId: "default-user",
  userName: "default",
  engine: UserEngine.REDIS,
  accessControl: AccessControl.fromAccessString('on ~* -@all')
});


// Create ElastiCache user group
const userGroup = new UserGroup(this, 'UserGroup', {
  engine: UserEngine.REDIS,
  users: [defaultUserNoAccess, user],
});

// Create Redis serverless cache
const cache = new ServerlessCache(this, 'test', {
  userGroup,
  serverlessCacheName: 'my-redis-cache', 
  description: 'Serverless Redis cache for demo'
  engine: elasticache.CacheEngine.REDIS_7,
  vpc,
});

// Create Lambda funciton passing needed information to connect with the Cache
const lambdaFunction = new Function(this, 'CacheFunction', {
  environment: {
    CACHE_ENDPOINT: cache.serverlessCacheEndpointAddress,
    CACHE_PORT: cache.serverlessCacheEndpointPort,
    CACHE_NAME: cache.serverlessCacheName,
    USER_NAME: user.userName ?? "",
  },
  runtime: Runtime.NODEJS_LATEST,
  handler: 'cache-handler.handler',
  code: Code.fromAsset(path.join(__dirname, '../lambda')),
  vpc,
  timeout: cdk.Duration.minutes(2),
});

// Give the lambda function the proper permission to call Redis
user.grant(lambdaFunction);

DocumentDB Serverless Support

No more overprovisioning or underutilizing your DocumentDB clusters! You can now deploy serverless DocumentDB configurations through our L2 constructs, letting you configure auto-scaling without managing instances.

This straightforward pattern makes it simple:

const cluster = new docdb.DatabaseCluster(this, 'DocumentDbCluster', {
  masterUser: {
    username: secret.secretValueFromJson('username').unsafeUnwrap(),
    password: secret.secretValueFromJson('password')
  },
  instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MEDIUM),
  vpc: vpc,
  instances: 1
});

CodeBuild Fleet Enhancements

For teams running large-scale CI/CD operations, we've significantly enhanced CodeBuild's fleet management capabilities. These improvements give you much more control over your build infrastructure:

// Create CodeBuild Fleet for large-scale CI/CD
const buildFleet = new codebuild.Fleet(this, 'CiCdFleet', {
  fleetName: 'large-scale-cicd-fleet',
  baseCapacity: 5,
  computeType: codebuild.FleetComputeType.LARGE,
  environmentType: codebuild.EnvironmentType.LINUX_CONTAINER
});

// Create high-performance fleet for critical builds
const performanceFleet = new codebuild.Fleet(this, 'PerformanceFleet', {
  fleetName: 'high-performance-fleet',
  baseCapacity: 2,
  computeType: codebuild.FleetComputeType.X2_LARGE,
  environmentType: codebuild.EnvironmentType.LINUX_CONTAINER
});

RDS Proxy Endpoints

Connection management just got easier with our new L2 construct for RDS Proxy Endpoints. This is particularly valuable for managing read/write splits or creating specialized connection points:

// Create RDS Proxy using L2 construct
const proxy = new rds.DatabaseProxy(this, 'RdsProxy', {
  proxyTarget: rds.ProxyTarget.fromCluster(cluster),
  secrets: [secret],
  vpc: vpc
});

// Create read-only endpoint using L2 construct
const readEndpoint = new rds.DatabaseProxyEndpoint(this, 'ReadOnlyEndpoint', {
  dbProxy: proxy,
  dbProxyEndpointName: 'read-only',
  targetRole: rds.ProxyEndpointTargetRole.READ_ONLY,
  vpc: vpc,
  vpcSubnets: vpc.selectSubnets({ 
    subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS 
  })
});

Community Highlights

Our CDK community continues to create amazing tools that make working with CDK even better. Here are some standout contributions from this month:

Special Recognition

We want to shine a spotlight on some extraordinary external contributors who made significant impacts this month:

Hung Tran - Implemented the RDS DatabaseProxyEndpoint L2 construct that many of you have been requesting
Kazuho Cryer-Shinozuka - Made multiple significant contributions including CloudFront origins IP address type support, CloudFront origins response completion timeout, Synthetics browser type for canary, Batch ECS execute command, and CodeBuild fleet overflow behavior
Ian Kerins - Implemented CodeBuild custom instance type and VPC support for Fleets
Tietew - Added Route53 SVCB and HTTPS resource record classes
Benoît Durand - Implemented Event Bus Logging Configuration support
Kyle Roach - Added support for new Bun lock file
Yuki Matsuda - Fixed RDS connections issue in DatabaseInstance.fromLookup
Kasra Ghaffari - Made two important StepFunctions fixes: distributed map execution in nested StateGraphs and DistributedMap permissions for run/redrive operations

We're incredibly grateful to these contributors and to everyone who files issues, suggests improvements, and helps make CDK better every day. Thank you!

Content from the Community

CDK Express Pipeline GitHub Diff Action by Rehan van der Merwe

If you've ever struggled with reviewing CDK changes in pull requests, you'll love this tool. Rehan has created an incredible GitHub Action that visualizes CDK diffs directly in your PRs! It runs diffs in parallel, collects outputs from multiple stacks, and filters out noisy resources for much cleaner diffs.

Check it out: CDK Express Pipeline GitHub Diff Action

CDK Booster by Marko (ServerlessLife)

Tired of waiting for Lambda bundling during CDK deployments? Marko has launched CDK Booster, a clever tool that dramatically speeds up AWS CDK bundling of TypeScript/JavaScript Lambdas without requiring any code changes!

Learn more: CDK Booster

Promptz.dev by Christian Bonzalet

While this came out a few months ago, I think this needed a special callout for the CDK rules that make your prompt life much easier! Highly recommend :)

Learn more: Promptz.dev

CDK Environment Management Guide by Thorsten Höger and Kenta Goto

If you're managing multiple environments with CDK, don't miss this excellent deep-dive from Thorsten Höger and Kenta Goto. They've published a comprehensive guide to CDK environment management, exploring the pros and cons of static versus dynamic stack creation patterns.

Learn more: CDK Environment Management: Static vs Dynamic Stack Creation

AWS CDK Tutorial by Rahul Sharma

For those new to CDK or looking to strengthen their fundamentals, Rahul Sharma from SourceFuse has created an excellent tutorial that walks through key concepts and practical implementations. This resource is particularly valuable for developers transitioning from console-based management to Infrastructure as Code with CDK.

Learn more: AWS CDK Tutorial

ACM exportable certificates by Feng He

Hear what Feng He (Principal Solution Eng at Flybuys) has to say about their experience contributing to CDK - and saved \$15000 per year for their organization.

Content from AWS

This month has been exceptionally productive for AWS teams using CDK across various domains. Here's a roundup of valuable content to help you level up your CDK skills:

Deep Packet Inspection for Streaming Content

For those working with high-value media content, the AWS team has published a comprehensive guide on implementing deep packet inspection for securing streaming content using CDK. The blog includes detailed CDK code examples that you can adapt for your own secure streaming infrastructure.

Read the full article: AWS CDK: Deep packet inspection for securing high-value streaming content in the cloud

Console to Code: Accelerating AWS Infrastructure Deployment

Many teams start by using the AWS Console but struggle with the transition to Infrastructure as Code. This practical guide walks through the journey from manual deployments to automated CDK pipelines, with specific strategies to accelerate the transition.

Learn more: Accelerating AWS infrastructure deployment: A practical guide to console to code

Building GraphQL APIs with AWS AppSync and .NET

.NET developers will appreciate this deep dive into creating GraphQL APIs using AWS AppSync with Direct Lambda Resolvers. The article provides CDK code samples for setting up the entire infrastructure using .NET.

Streamlining Spark Development with Data Solutions Framework

The Data Solutions Framework team has released a guide on simplifying Spark application development on Amazon EMR. This framework uses CDK to provide higher-level abstractions that help data engineers focus on business logic rather than infrastructure details.

Explore more: Streamline Spark application development on Amazon EMR with the Data Solutions Framework on AWS

Amazon ECS Blue/Green Deployments with Lifecycle Hooks

For container enthusiasts, this article explains how to extend deployment pipelines with Amazon ECS Blue/Green deployments and lifecycle hooks. It includes detailed CDK examples for setting up complex deployment workflows.

Dive in: Extending deployment pipelines with Amazon ECS Blue/Green deployments and lifecycle hooks

Creating a Private SageMaker Ground Truth Workforce with CDK

Machine learning practitioners will benefit from this guide on setting up a private workforce for Amazon SageMaker Ground Truth using CDK. It demonstrates how to automate the provisioning of labeling workforces for sensitive ML projects.

Learn more: Create a private workforce on Amazon SageMaker Ground Truth with the AWS CDK

How Can You Be Involved

Contributing to CDK

CDK thrives because of community contributions, and we'd love to have you join in! Here are some ways you can make a difference:

Report Issues: Found a bug or have a feature request? Open an issue to help us improve
Contribute Code: Looking to get your hands dirty? Check out our good first issues to get started
Documentation: Help make CDK more accessible by improving our CDK Guide
RFCs: Shape the future of CDK by participating in Request for Comments discussions

Community Engagement

The CDK community is friendly, helpful, and always learning. Join the conversation:

CDK Community Slack: Chat with thousands of CDK users and experts at cdk.dev
AWS re:Post: Ask questions and share your knowledge on AWS re:Post
GitHub Discussions: Dive deep into CDK topics in CDK Discussions

The AWS CDK team is committed to making cloud development more accessible and enjoyable. Keep building amazing things, and we'll keep improving the tools to help you succeed!

Happy coding!

[Boost]

Praneeta Prakash — Thu, 25 Sep 2025 20:49:49 +0000

Thorsten Hoeger for AWS Heroes

Sep 25 '25

CDK Environment Management: Static vs Dynamic Stack Creation

#aws #cdk #devops

Comments 2

10 min read

AWS CDK in August 2025

Praneeta Prakash — Wed, 10 Sep 2025 17:32:16 +0000

Major Features
- Amazon Bedrock Guardrails L2 Construct
- ECS Native Blue/Green Deployments
- Enhanced CLI Experience with Interactive Feature Flags
Notable Fixes
Community Spotlight
- Community Content
AWS content updates
Want to be more involved?
Getting Started Resources

Welcome to the AWS CDK monthly update for August 2025! This month brought significant enhancements across the CDK ecosystem, with major improvements to developer experience, new service integrations, and enhanced deployment capabilities. Let's dive into the key updates that will help you build better cloud applications.

Major Features

Amazon Bedrock Guardrails L2 Construct (Alpha)

We're excited to introduce L2 constructs for Amazon Bedrock Guardrails, making it easier to implement responsible AI practices in your applications. This new alpha feature allows you to define content filters, topic restrictions, and safety policies directly in your CDK code.

import { Guardrail } from '@aws-cdk/aws-bedrock-alpha'; 
const guardrail = new Guardrail(this, 'MyGuardrail', { 
  name: 'content-safety-guardrail', 
  description: "'Guardrail for content safety', "
  contentPolicyConfig: { 
    filtersConfig: [{ 
      type: 'HATE', 
      inputStrength: 'HIGH', 
      outputStrength: 'HIGH' 
    }] 
  }, 
  topicPolicyConfig: { 
    topicsConfig: [{ 
      name: 'investment-advice', 
      definition: 'Investment advice and financial recommendations', 
      type: 'DENY' 
    }] 
  } 
});

While this is supported in the native CDK library, you can explore additional CDK constructs built specially for Gen AI use cases here.

ECS Native Blue/Green Deployments

ECS services now support native blue/green deployments through L2 constructs, enabling zero-downtime deployments with automatic rollback capabilities.

import { FargateService, AlternateTargetConfiguration } from 'aws-cdk-lib/aws-ecs'; 
const service = new FargateService(this, 'MyService', { 
  cluster, 
  taskDefinition, 
  alternateTargetConfiguration: new AlternateTargetConfiguration({ 
    containerName: 'web', 
    containerPort: 80, 
    listenerPort: 8080 
  }) 
});

Enhanced CLI Experience with Interactive Feature Flags

The CDK CLI now provides an interactive experience for managing feature flags, making it easier to configure and understand the impact of different CDK features. Read more here.

$ cdk flags --unstable=flags --set --recommended --all 
Feature Flag                              Recommended Value            User Value 
* @aws-cdk/...                              true                         false 
* @aws-cdk/...                              true                         false 
* @aws-cdk/...                              true                         <unset> 
  Synthesizing... 
    Resources 
    [~] AWS::S3::Bucket MyBucket 
    └─ [~] Properties 
        └─ [~] Encryption 
                ... 
    Number of stacks with differences: 2 
  Do you want to accept these changes? (y/n) y 
  Resynthesizing...

Notable Fixes

S3 Deployment: Fixed intermittent CloudFront invalidation errors during deployments
EKS: Resolved Helm command execution issues with ECR public registry authentication
Lambda: Improved startup time for large applications by optimizing lazy loading
CloudWatch: Fixed AlarmRule.concat to properly handle empty operands
Step Functions: Corrected Bedrock Agent service IAM prefix mapping

Community Spotlight

Big shout-outs to phuhung273 for 3 merged PRs in August! They made multiple high impact contributions including Docker build networking enhancements (#34725), CloudWatch alarm rule fixes (#34757), and comprehensive RDS engine version updates across PostgreSQL, SQL Server, and MySQL (#35013).

We also celebrate mazyu36 for their outstanding work with 3 impactful contributions - modernizing RDS VPC security group lookups (#34906) and improving EKS documentation structure (#34783).

Special recognition goes to badmintoncryer (#34962), xuxey (#35223), richarddotcodes (#35025), maramure (#35060), and jaw111 (#34712) for their valuable contributions spanning ECS volume optimization, S3 Tables security policies, cross-region VPC endpoints, WebSocket API management, and SNS filtering capabilities.

Community Content

Kenta Goto wrote an extremely helpful article on “How to choose validation approaches in AWS CDK”.
Jeroen Reijn has tips on Enabling AWS Budget Notifications with SNS using AWS CDK
Lee Gilmore compares AWS CDK Blueprints vs Custom Constructs vs Aspects in this article.

AWS content updates

Here are some recent blogposts that demonstrate use of CDK to build various applications on AWS.

Want to be more involved?

The CDK team runs community meetings every quarter to discuss new features, best practices and highlight community-built projects. We publish videos here in a community run YouTube channel and have a 10k+ active community discussing all things CDK and AWS in CDK.dev Community Slack. Join us!

We are also looking for community reviewers to help us move faster on PRs. Check out open PRs here and provide your review and guidance to other CDK contributors.

Getting Started Resources

Have feedback or questions about these updates? Join the conversation in our GitHub Discussions.

Happy building! 🚀

The AWS CDK Team

AWS CDK in July 2025

Praneeta Prakash — Thu, 14 Aug 2025 01:13:10 +0000

New Abstractions

Amazon Bedrock Inference Profiles Support
Amazon S3 Tables L2 Construct Support
CloudWatch Logs Transformer Support
RDS Database Insights for Instances
Enhanced CloudWatch Dashboard Features

CLI Enhancements

Enhanced Diff Command with Move Detection
Feature Flag Management

Documentation Changes
Community and Content Highlights

Contributor Highlight
Community Events
Community published content

Welcome to the July 2025 AWS CDK monthly update! This month brought significant new features, improvements, and fixes across the CDK ecosystem. Here you will find the key highlights.

New Abstractions

Amazon Bedrock Inference Profiles Support

We're excited to announce comprehensive support for Amazon Bedrock Inference Profiles in the AWS CDK Bedrock Alpha construct library. This feature enables better cost tracking, model usage optimization, and cross-region inference capabilities.

Key capabilities:
• Application Inference Profiles: User-defined profiles for cost tracking and model usage monitoring
• Cross-Region Inference Profiles: System-defined profiles for seamless traffic distribution across AWS regions
• Prompt Routers: Intelligent prompt routing capabilities

import * as bedrock from '@aws-cdk/aws-bedrock-alpha'; 

// Create an application inference profile for cost tracking 
const appProfile = new bedrock.ApplicationInferenceProfile(this, 'MyAppProfile', { 
  applicationInferenceProfileName: 'my-cost-tracking-profile', 
  modelSource: bedrock.BedrockFoundationModel.ANTHROPIC_CLAUDE_3_5_SONNET_V1_0, 
  description: 'Profile for tracking model usage costs', 
}); 

// Create a cross-region inference profile for resilience 
const crossRegionProfile = bedrock.CrossRegionInferenceProfile.fromConfig({ 
  geoRegion: bedrock.CrossRegionInferenceProfileRegion.US, 
  model: bedrock.BedrockFoundationModel.ANTHROPIC_CLAUDE_3_5_SONNET_V1_0, 
}); 

// Grant usage permissions to other resources appProfile.grantProfileUsage(myLambdaFunction);

Amazon S3 Tables L2 Construct Support

Amazon S3 Tables deliver the first cloud object store with built-in Apache Iceberg support and streamline storing tabular data at scale. L2 constructs are added to AWS CDK to support the base CfnNamespace and CfnTable constructs with a more concise user interface, recommended defaults, and in-built validations.

// Create namespace
const namespace = new Namespace(this, 'MyNamespace', {
  namespaceName: 'analytics_namespace',
  tableBucket: myTableBucket,
});
// Create table with schema and maintenance settings
const table = new Table(this, 'MyTable', {
  tableName: 'user_events',
  namespace: namespace,
  openTableFormat: OpenTableFormat.ICEBERG,
  icebergMetadata: {
    icebergSchema: {
      schemaFieldList: [
        { name: 'id', type: 'int', required: true },
        { name: 'timestamp', type: 'timestamp' }
      ]
    }
  },
  compaction: {
    status: Status.ENABLED,
    targetFileSizeMb: 128,
  },
  snapshotManagement: {
    status: Status.ENABLED,
    maxSnapshotAgeHours: 48,
    minSnapshotsToKeep: 5,
  }
});

CloudWatch Logs Transformer Support

New support for CloudWatch Logs Transformers allows you to process and transform log data before it's stored, providing powerful data processing capabilities.

// Create a log group
const logGroup = new logs.LogGroup(this, 'MyLogGroup');

// Create a JSON parser processor
const jsonParser = new logs.ParserProcessor({
  type: logs.ParserProcessorType.JSON
});

// Create a processor to add keys
const addKeysProcessor = new logs.JsonMutatorProcessor({
  type: logs.JsonMutatorType.ADD_KEYS,
  addKeysOptions: {
    entries: [{
      key: 'metadata.transformed_in',
      value: 'CloudWatchLogs'
    }]
  }
});

// Create a transformer with these processors
new logs.Transformer(this, 'Transformer', {
  transformerName: 'MyTransformer',
  logGroup: logGroup,
  transformerConfig: [jsonParser, addKeysProcessor]
});

RDS Database Insights for Instances

Database Insights support has been extended to RDS instances, providing enhanced monitoring capabilities similar to what was previously available only for Aurora clusters.

import { DatabaseInstance, DatabaseInstanceEngine, DatabaseInsightsMode } from 'aws-cdk-lib/aws-rds';
const instance = new DatabaseInstance(this, 'MyDatabase', {
  engine: DatabaseInstanceEngine.mysql({ version: MysqlEngineVersion.VER_8_0 }),
  instanceType: ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.MICRO),
  vpc: myVpc,
  // Enable Database Insights for enhanced monitoring
  databaseInsightsMode: DatabaseInsightsMode.STANDARD,
});

Enhanced CloudWatch Dashboard Features

New CloudWatch dashboard capabilities include search expressions and improved metric visibility controls.

import { Dashboard, GraphWidget, Metric } from 'aws-cdk-lib/aws-cloudwatch';
const dashboard = new Dashboard(this, 'MyDashboard');
dashboard.addWidgets(
  new GraphWidget({
    title: 'Application Metrics',
    // New search expression support
    searchExpression: 'SEARCH(\'{AWS/Lambda,FunctionName} MetricName="Duration"\')',
    // Enhanced metric visibility controls
    left: [
      new Metric({
        namespace: 'AWS/Lambda',
        metricName: 'Duration',
        // New properties for better control
        id: 'duration-metric',
        visible: true,
      }),
    ],
  })
);

CLI Enhancements

Enhanced Diff Command with Move Detection

The cdk diff command now intelligently detects when resources are moved rather than deleted and recreated, providing clearer insights into your infrastructure changes.

# Enable move detection in diff output
cdk diff —include-moves

# Example output now shows:

Stack Service
Resources
[+] AWS::CloudWatch::Alarm SuccessRate SuccessRateAB36B766 (OR move from Messaging.SuccessRateAB36B766 via refactoring)

Stack Messaging
Resources
[-] AWS::CloudWatch::Alarm SuccessRate SuccessRateAB36B766 destroy (OR move to Service.SuccessRateAB36B766 via refactoring)

Feature Flag Management

The AWS CDK uses feature flags to enable potentially breaking behaviors in a release. Flags are stored as Context values and the AWS CDK values in cdk.json or (~/.cdk.json). The new feature flag management allows you to configure individual flags more easily. This requires aws-cdk-lib version >= 2.209.0.

# Modify a specific feature flag
cdk flags --unstable=flags --set @aws-cdk/aws-redshift:columnId --value="true"

# View all active and missing feature flags
cdk flags --unstable=flags --all

Documentation Changes

A new way to contribute to the AWS CDK Developer Guide - Now, any page on the Dev Guide website has an “Edit this page on GitHub” link that takes you directly to the source-of-truth file in aws-cdk-guide GitHub repository.

Community and Content Highlights

Contributor Highlight

HUGE thanks to Hung Tran for 6 merged PRs in July! They made multiple high impact contributions including Bedrock models, ECS Windows 2025 AMI, Lambda insights versions. We also celebrate mazyu36, Tietew and badmintoncryer for their impactful contributions to the CDK.

Community Events

The AWS Community in Japan held a CDK Conference in July that was attended by over 500 people (video link). Many thanks to the JAWS community organizers for running this event. Some of the popular sessions were (content is in Japanese):

Community published content

Do You Really Know the Difference Between L1, L2, and L3 CDK Constructs? by Yusuf Adeyemo
How to Choose Validation Approaches in AWS CDK by Kenta Goto
Structuring and Refactoring AWS CDK Projects: Best Practices and Patterns by Robert Dahlborg

Feedback

We continue to value your feedback and contributions. If you encounter any issues or have suggestions for improvements, please:

• Report issues on our GitHub repository
• Join discussions in our community Slack

The AWS CDK team is committed to making infrastructure as code more accessible, powerful, and enjoyable. These July updates represent significant steps forward in that mission, with enhanced AWS service support, improved developer experience,
and better tooling.

Happy coding with CDK!

AWS CDK in June

Praneeta Prakash — Tue, 08 Jul 2025 11:33:05 +0000

CDK Updates

Node.js Runtime Updates
CDK Migrate Improvements
integ-runner Toolkit-Lib Engine
AWS Blogs
Request for Comments (RFCs)

Community and Content Highlights

Open Source tools built by the community
Content by the Community
Community Contributions to the CDK

Writing these posts are the highlight of my month - it is incredibly satisfying to see all the work the team and community did to collectively improve our experience with managing infrastructure on AWS.

AWS CDK is an open source software development framework to define your infrastructure in code. If you are new to CDK, I recommend starting with AWS docs. You can also read some of the popular posts from the community on https://cdk.dev/posts.

CDK Updates

We made a bunch of stability improvements in June. Here are some of the key takeaways -

Node.js Runtime Updates

This month marked an important milestone in our Node.js support strategy. We officially dropped support for Node.js 14 and 16, aligning with AWS's announced end-of-support timeline. Additionally, the aws-cdk bundle now targets Node.js 18, ensuring better performance and access to modern JavaScript features.

CDK Migrate Improvements

We updated the cdk-from-cfn dependency to resolve multiple bugs in the cdk migrate command, improving the reliability of CloudFormation template migrations to CDK code.

integ-runner Toolkit-Lib Engine

The CDK integ-runner now supports a new bundled engine that eliminates the dependency on having the CDK CLI installed. This new engine is currently in preview and can be enabled using the integ-runner --unstable=toolkit-lib-engine flag. Its direct integration with the CDK Toolkit code should provide a more consistent experience for Toolkit operations and (eventually) increase the performance. Please let us know your feedback or if you encounter issues.

AWS Blogs

Here are AWS blogs launched in June that help builders on CDK get started with different AWS services.

Streamline personalization development: How automated ML workflows accelerate Amazon Personalize implementation (06/02/2025) by Reagan Rosario and Nensi Hakobjanyan
Improve operational processes for AWS Elemental MediaConnect using AWS CDK (06/12/2025) by Jamie Mullan
Announcing the new AWS CDK EKS v2 L2 Constructs (06/19/2025) by Matteo Luigi Restelli

Request for Comments (RFCs)

We rely on your feedback during development. RFCs are our preferred way of sharing early designs on features. Please feel free to upvote and add your comments on any open RFCs here. We are currently looking for feedback on -

Community and Content Highlights

I want to start with our community updates - we had our first Community Meeting! Thank you for the survey responses, we will be announcing the next meeting soon via GitHub Issue and CDK slack. We love to highlight demos from the community on open-source tools built on CDK. Here are a couple of much loved community-built open-source tooling, give them a star!

Open Source tools built by the community

Name	Description	Author
aws-lambda-handler-cookbook	provides a working, open source based, AWS Lambda handler skeleton Python code including deployment code with CDK and a pipeline.	Ran Isenberg
iam-floyd	Fluent-interface generator for AWS IAM policy statements, covering all services/actions/conditions	Daniel Schroeder
safe-ts-env	A TypeScript library that provides type-safe environment configuration	Dakota Lewallen

Content by the Community

Among blogposts published by our community, I would love to call out How to automatically set up a website on AWS behind a real domain with AWS CloudFront and cross account roles by our DevTools Hero Johannes Koch. This addresses a common issue enterprises run into, please have a read.

Community Contributions to the CDK

This month, we applaud the helpful contributions made by Hung Tran.

Added support for uv package manager in Lambda Python functions on 33880
Add support for engineLifecycleSupport configuration in L2/L3 constructs for RDS Instances 34719

Huge thanks to all our community contributors!

Thanks for your time! Feel free to reach out to the CDK team on our Slack channel with any questions. Happy coding! 🚀

AWS CDK in Action — May 2025: Empowered Deployments, Governance, and Community

Praneeta Prakash — Fri, 13 Jun 2025 02:02:53 +0000

In May 2025, AWS CDK introduced enhancements—especially around the Toolkit Library—to help you build custom tools, enable best practices, and automatic drift detection. Here are some of the top launches from CDK in May.

1: Programmatic Access with the Toolkit Library (GA)

The CDK Toolkit Library enables you to perform CDK actions programmatically through code instead of using CLI commands. You can use this library to create custom tools, build specialized CLI applications, and integrate CDK capabilities into your development workflows.

Getting Started with the Toolkit Library

The following example shows how to create and deploy a simple S3 bucket using the CDK Toolkit Library:

// Import required packages
import { Toolkit } from '@aws-cdk/toolkit-lib';
import { App, Stack } from 'aws-cdk-lib';
import * as s3 from 'aws-cdk-lib/aws-s3';

// Create and configure the CDK Toolkit
const toolkit = new Toolkit();

// Create a cloud assembly source with an inline app
const cloudAssemblySource = await toolkit.fromAssemblyBuilder(async () => {
const app = new App();
const stack = new Stack(app, 'SimpleStorageStack');

// Create an S3 bucket in the stack
new s3.Bucket(stack, 'MyFirstBucket', {
versioned: true
});

return app.synth();
});

// Deploy the stack
await toolkit.deploy(cloudAssemblySource);

Use the Toolkit Library to build robust, integrated CI/CD pipelines, developer tools, or dashboards—no CLI wrappers required. Read more here. Keep reading to see how AWS Amplify uses toolkits to improve developer experience!

2: Ensuring Reliability with Drift Detection

Imagine shipping a small tag update directly in the console—only to later discover that a stack's configuration no longer matches your CDK code. The cdk drift command empowers you to identify these out-of-band changes before they impact production.

How it works: cdk drift uses CloudFormation’s Detect Stack Drift API to compare your deployed stack against its CDK-defined template.
Usage in CI: npx cdk drift --fail checks for drift and fails if discrepancies are found.
Programmatic Access: You can also call Toolkit.drift() programmatically via the Toolkit Library, enabling integrated drift checks in custom scripts.

By proactively detecting drift, you reduce unexpected downtime and maintain confidence in your deployments. Read more here.

3: Enable Best-Practices with Property Injection (Preview)

CDK launched Property Injection so your organization can standardize default construct properties—providing a template for builders to follow best practices while retaining full flexibility to override. Builders can import these recommended defaults into their app, while having the flexibility to override them if needed.

First, create a property injector for Amazon S3 buckets:

import { IPropertyInjector, InjectionContext } from 'aws-cdk-lib';
import { Bucket, BucketProps, BlockPublicAccess } from 'aws-cdk-lib/aws-s3';

export class SecureBucketDefaults implements IPropertyInjector {
  public readonly constructUniqueId: string;

  constructor() {
    this.constructUniqueId = Bucket.PROPERTY_INJECTION_ID;
  }

  public inject(originalProps: BucketProps, _context: InjectionContext): BucketProps {
    return {
      // Set security defaults
      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,
      enforceSSL: true,

      // Include original props to allow overrides
      ...originalProps,
    };
  }
}

Then, use the injector in your CDK application:

import { App, Stack } from 'aws-cdk-lib';
import { Bucket } from 'aws-cdk-lib/aws-s3';
import { SecureBucketDefaults } from './secure-bucket-defaults';

// Attach injectors when creating the App
const app = new App({
  propertyInjectors: [new SecureBucketDefaults()]
});

const stack = new Stack(app, 'MyStack');

// This bucket automatically gets the default properties
const myBucket = new Bucket(stack, 'MyBucket');

Apply injectors at the App, Stage, or Stack level. Read more here.

4: AWS Amplify CDK Toolkit-Powered Sandboxes

Amplify’s sandbox now integrates with the CDK Toolkit Library directly (PR #2503). CDK Toolkit emits structured JSON events for synth, diff, deploy, etc.
Because the Toolkit Library returns typed results, Amplify (or any other tool calling CDK) no longer has to parse raw text - and can take full control of their own output and presentation. Read more here

5: Community stars

Collaboration fuels innovation. In May, two community contributions stood out:

Deepu Mohan Puthrote contributed OidcProviderNativeConstruct here. Thanks for working with the CDK team on getting this important feature in!
Kenta Goto, one of our top community contributors and AWS dev tools Heroes, wrote a very helpful article on property injectors in CDK.

Want to share your story? Tag posts with #awsCDK or publish on https://cdk.dev/posts to be featured next month.

That’s the story of May 2025—building integrated tooling, enabling best practices, and celebrating community achievements. Share your feedback and happy building!

Forem: Praneeta Prakash

CDK update - March 2026

Index

TL;DR

Major Features

CDK Mixins — From Preview to Stable

EKS v2 Graduates to Stable 🚀

CLI Improvements

--revert-drift Option

Concurrent Asset Builds & publish-assets

cdk diff --method & cdk destroy --concurrency

Additional CLI Updates

New L2 Constructs

MediaPackage V2 (Alpha)

Service Enhancements

DynamoDB Cross-Account Global Tables

ALB JWT Authentication

OpenSearch S3 Vectors Engine

Kinesis Firehose Dynamic Partitioning

Glue Typed Partition Projection (Alpha)

Bedrock AgentCore: fromCodeAsset

More Service Updates

Community Highlights

Top External Contributors

Additional Contributors

Community Content & Resources

How Can You Be Involved

Report Issues

Contribute Code

Join the Conversation

Star the Repo

From One Prompt to a Deployed Full-Stack App on AWS

Prerequisites

What's a Kiro Power?

Setup

Installation

The Prompt

Phase 1: Backend Setup

Phase 2: Sandbox Deployment

Phase 3: Frontend & Testing

Phase 4: Production Deployment

Cleanup

Links

AWS CDK Community Update: Jan/Feb 2026!

What's New

Community at a Glance

Upgrade Now

TL;DR

Major Features

CDK Mixins (Preview) - Add Features to Any Construct

Amazon EKS Enhancements

Bedrock AgentCore Expansion

ECS Deployment Strategies

AWS Glue Typed Partition Projection

RDS Enhancements

CloudWatch Logs Deletion Protection

EC2 VPC Flow Logs to Firehose

API Gateway v2 EventBridge Integration

Kiro Power for AWS Infrastructure as Code

More Features

Community Highlights

Top External Contributors

Get Involved

Ongoing

Community Showcase

Learning & Best Practices

Monitoring & Operations

Infrastructure Patterns

Developer Tools

AI & Advanced Use Cases

Video Content

Thank You!

re:Invent Special Update from AWS CDK

Index

TL;DR

A Message of Gratitude

Major Features

CDK Mixins - Developer Preview

AI-Powered Development

AWS IaC MCP Server

`--revert-drift` Option

Concurrent Asset Builds & `publish-assets`

`cdk diff --method` & `cdk destroy --concurrency`

Bedrock AgentCore: `fromCodeAsset`