AWS Blocks: Redefining Local-First Cloud Development

AWS has officially announced the Public Preview of AWS Blocks, an open-source TypeScript framework designed to address one of the most persistent bottlenecks in modern cloud development: local environment emulation and offline workflows without requiring an active AWS account.

The launch of AWS Blocks signals an industry-wide paradigm shift from traditional Infrastructure-as-Code (IaC) to Infrastructure-from-Code (IFC), where cloud topology is automatically inferred directly from application runtime logic.

The Paradigm of Infrastructure-from-Code (IFC) with TypeScript

Rather than writing hundreds of lines of complex YAML or manually configuring cloud resources, AWS Blocks allows developers to define both application execution and infrastructure requirements within a single unified TypeScript codebase.

Each functional block is a self-contained npm package that represents a distinct backend capability. As developers compose these Blocks, the framework automatically translates and provisions corresponding cloud resources using the AWS Cloud Development Kit (CDK).

// aws-blocks/index.ts
import { Scope, ApiNamespace, KVStore } from '@aws-blocks/blocks';

const scope = new Scope('my-app');
// This Block automatically maps to an Amazon DynamoDB table upon deployment
const cache = new KVStore(scope, 'cache'); 

export const api = new ApiNamespace(scope, 'api', () => ({
  getValue: (key: string) => cache.get(key),
  setValue: (key: string, value: string) => cache.set(key, value),
}));

A standout advantage of this architecture is its ability to enforce end-to-end type safety directly from the backend data schema to frontend API invocations, completely eliminating the need for an external code generation step.

Uncompromised Local-First Workflows Powered by PGlite (WASM)

The primary barrier to building serverless or cloud-native applications has always been the dependency on live cloud connections or resource-heavy local container orchestration. AWS Blocks eliminates this friction by integrating PGlite—a lightweight, fully relational build of PostgreSQL compiled to WebAssembly (WASM).

When running in local mode, AWS Blocks spins up a fully functional backend environment (including a local Postgres database, user authentication mechanisms, and a real-time pub/sub pipeline) entirely within the Node.js runtime on the developer's local machine. This setup enables rapid offline iteration with zero cloud cost:

• Database: Local WebAssembly-driven PostgreSQL (PGlite) that maps seamlessly to Amazon Aurora PostgreSQL in production.
• Key-Value Store: In-memory mock storage locally, compiling to Amazon DynamoDB on deployment.
• File Storage: A local directory wrapper, provisioned as an Amazon S3 bucket on production.

To bootstrap a new project, developers only need to run a single command:

npx @aws-blocks/create-blocks-app

Architected with AI Coding Agents in Mind

In an era dominated by AI-driven development, AWS Blocks introduces a unique structural approach by being explicitly designed for AI coding agents.

The framework ships with built-in steering files designed to guide autonomous AI agents (such as Cursor or Claude Code). These context helpers ensure that when an AI agent generates code, it strictly conforms to proven cloud-native architectural patterns on AWS. This significantly reduces the configuration bugs and anti-patterns often introduced when AI agents attempt to write raw IaC files.

High-Level Comparison: AWS Blocks vs. AWS Amplify

While both toolkits aim to streamline full-stack engineering on AWS, they use distinct approaches:

Feature	AWS Blocks	AWS Amplify (Gen 2)
Core Philosophy	Local-first, type-safe Infrastructure-from-Code with explicit backend control.	High-level infrastructure abstraction to maximize frontend-to-cloud speed.
Local Environment	100% offline local-first emulation via PGlite (WASM) and mock runtimes.	Cloud-dependent sandbox environments per developer for resource provisioning.
Control Level	Highly transparent; seamlessly integrates with custom CDK constructs.	Managed abstraction; complex infrastructure details are largely hidden.
Type Safety	Natural end-to-end type safety from schema to frontend out of the box.	Enforced via generated client libraries and schema bindings.

Developer Takeaways

The release of AWS Blocks represents a calculated effort by AWS to retain the TypeScript/Node.js ecosystem amid a broader shift toward independent, local-first database platforms. The ability to build offline and compile straight into standard AWS CDK assets provides massive utility for engineering teams aiming to optimize local iteration and eliminate cloud sandbox overhead.

AWS Blocks is currently available under the Apache 2.0 open-source license on GitHub at aws-devtools-labs/aws-blocks. Developers can dive in today to get an early look at the future of Infrastructure-from-Code.

---

Content assisted by AI (Amy 🌸). Reviewed by the author.