MicroServerless - Inspired by microservices, built on Lambda

Background

Inspiration

Managing microservices with Kubernetes introduces steep learning curves and operational complexity. We were inspired by the idea of simplifying microservice orchestration using fully managed AWS services (especially AWS Lambda) to reduce overhead while maintaining scalability, reliability, and configuration-as-code principles.

What it does

MicroServerless is a production-ready, serverless microservice orchestration framework built on AWS. It allows developers to define microservices with YAML files and deploy them using AWS CDK. The framework automatically provisions:

Lambda functions for compute
API Gateway for service routing
DynamoDB, RDS, or Aurora for persistence
Secrets Manager & KMS for secure credentials
Route 53 and ACM for HTTPS and custom domains

Services are deployed and managed like Kubernetes pods/services, but with AWS-native infrastructure.

How we built it

The project is structured as an AWS CDK app using TypeScript. Here’s how it works:

Developers define services in YAML (e.g., hello-service.yaml).
CDK parses configurations and deploys AWS infrastructure.
The lib/ folder includes custom CDK constructs for Lambda, API Gateway, DynamoDB, VPC, etc.
Ingress is managed separately using ingress/*.yaml for routing setup.
Scripts automate build, deployment, and teardown of services.

Project tree:

serverless-microservices/
├── config/          # Service configurations
├── ingress/         # API Gateway + Route 53 ingress configs
├── lib/             # CDK constructs
├── src/             # Lambda source code
├── templates/       # YAML templates
├── scripts/         # Build + deploy automation
└── bin/deploy.ts    # CDK entry point

Challenges we ran into

Mapping Kubernetes-like abstractions to AWS-native components required careful design.
Dynamically generating CDK constructs from YAML configurations demanded robust parsing and validation.
Managing custom domains and HTTPS (ACM + Route 53) added complexity to the ingress layer.
Ensuring clean teardown of resources like DynamoDB tables and API mappings took iterative refinement.

Accomplishments that we're proud of

Achieved a Kubernetes-like developer experience using only serverless AWS components.
Fully automated infrastructure provisioning through YAML-based configuration.
Built a flexible ingress system supporting Route 53, ACM, and multiple paths/domains.
Enforced security best practices (KMS encryption, least-privilege IAM, Secrets Manager).

What we learned

AWS CDK is powerful for infrastructure-as-code but needs strong abstractions to scale.
Managing secrets and domain routing in serverless systems requires careful orchestration.
YAML-based service definitions make microservices declarative and easier to onboard new developers.
Abstracting cloud complexity improves development speed and reduces ops burden.