AWS Builder Center

AWS-BLOCKS-CHALLENGE-1

Discover how to build full-stack cloud applications locally with zero cloud costs using type-safe RPCs and embedded mocks, before deploying directly to Amazon DynamoDB and AWS Lambda without changing code.

🌟 Introduction: The Full-Stack Challenge for Student Builders

When students start building cloud-connected web applications, they typically face three common roadblocks:
  1. Repetitive Boilerplate: Writing tedious  fetch() ,  axios , or REST endpoint routing and manual JSON parsing on both the client and server.
  1. Type Disconnects: Maintaining two separate sets of TypeScript types across the frontend and backend, leading to runtime bugs when APIs evolve.
  1. Cloud Friction & Cost: Needing an active AWS account, configuring IAM roles, and incurring potential cloud costs just to test a simple prototype.
To solve this, I built the Student Task Tracker using AWS Blocks and React 18. AWS Blocks allows you to develop locally with zero cloud costs using built-in mocks and deploy directly to AWS services like Amazon DynamoDB and AWS Lambda with zero code modifications.



🏗️ High-Level System Architecture

AWS Blocks eliminates manual REST API endpoints by using a lightweight JSON-RPC 2.0 protocol over a single endpoint ( /aws-blocks/api ). The frontend imports a generated type-safe client that directly exposes backend methods as standard asynchronous JavaScript functions.




🧩 Core Building Blocks Explained

1.  Scope 

The  Scope  object defines the boundary and namespace for all backend cloud resources:
typescriptconst scope = new Scope('student-task-manager');

2.  KVStore 

 KVStore  provides a high-performance Key-Value data store. During development, it writes to an embedded file mock under  .bb-data/ . In production, AWS Blocks automatically binds it to Amazon DynamoDB.
typescriptconst store = new KVStore<Task>(scope, 'tasks');

3.  ApiNamespace 

 ApiNamespace  registers functions as callable RPC methods with full type inference across the wire:
typescriptexport const api = new ApiNamespace(scope, 'api', () => ({ async getTasks(): Promise<Task[]> { const tasks: Task[] = []; for await (const entry of store.scan()) { if (entry.value) tasks.push(entry.value); } return tasks.sort((a, b) => b.createdAt - a.createdAt); }, async addTask(title: string): Promise<Task> { const id = crypto.randomUUID(); const task: Task = { id, title: title.trim(), completed: false, createdAt: Date.now(), }; await store.put(id, task); return task; }, async updateTask(id: string, updates: Partial<Task>): Promise<Task> { const existing = await store.get(id); if (!existing) throw new Error(`Task not found`); const updated = { ...existing, ...updates }; await store.put(id, updated); return updated; }, async deleteTask(id: string): Promise<{ success: boolean }> { await store.delete(id); return { success: true }; }}));



⚡ The Frontend Experience: Calling APIs as Native Functions

In the React frontend ( src/App.tsx ), there is no need for  fetch()  or URL strings:
typescriptimport { api } from 'aws-blocks';// 1. Add Task (Create)const newTask = await api.addTask("Study for AWS Cloud Practitioner");// 2. Fetch Tasks (Read)const allTasks = await api.getTasks();// 3. Mark Complete (Update)await api.updateTask(task.id, { completed: true });// 4. Delete Task (Delete)await api.deleteTask(task.id);



☁️ Local Development vs. AWS Cloud Parity

Layer
Local Development (npm run dev)
AWS Cloud Deployment
Backend Compute
Local Node.js TSX Process (:3001)
AWS Lambda (Serverless)
Database
Embedded .bb-data/ File Mock
Amazon DynamoDB
Frontend Delivery
Vite Dev Server (:3100)
Amazon CloudFront + Amazon S3
API Protocol
JSON-RPC 2.0 via Local Proxy
Amazon API Gateway
Cloud Cost
$0.00
Serverless Pay-as-you-go



💡 Key Learnings for Student Builders

  1. Type Safety Prevents Regressions: Having a single shared TypeScript contract between frontend and backend eliminates entire classes of runtime errors.
  1. Local-First Speed: Testing against local database mocks enables rapid development and instant UI feedback without waiting for cloud deployments.
  1. Seamless Cloud Path: When you are ready for staging or production, you do not have to rewrite your data access layer.



🔗 Project Links & Code Repository

  • License: Apache-2.0
  • Technologies: AWS Blocks, React 18, TypeScript, Vite, Amazon DynamoDB


Thank you for reading! If you are a student builder or cloud enthusiast, give AWS Blocks a try for your next hackathon or prototype!
11:30 AM
# OUTPUT






Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article