cloudless
by skunxicat
aws-lambda lambda-layer

Lambda Layers Breakthrough

July 29, 2025

The Missing Piece

Today we completed the cloudless ecosystem with lambda-shell-layers. What started as a solution to avoid rebuilding tools in every Docker image became something much bigger.

The Problem

Every shell-based Lambda function needed the same tools:

  • qrencode for QR codes
  • htmlq for HTML parsing
  • imagemagick for image processing
  • pandoc for document conversion

We were rebuilding these in every Dockerfile. Slow builds, large images, repeated work.

The Solution

Lambda layers with pre-built, statically-linked binaries:

# Pick exactly what you need
provider:
  layers:
    - arn:aws:lambda:region:account:layer:ql4b-shell-qrencode:1
    - arn:aws:lambda:region:account:layer:ql4b-shell-htmlq:1

functions:
  api:
    environment:
      PATH: "/opt/bin:${env:PATH}"

Why This Changes Everything

True Composability: Mix and match tools like Lego blocks Minimal Runtime: Base image stays tiny, layers add functionality
Shared Caching: Lambda caches layers across functions Community Growth: Anyone can contribute new tools

The Ecosystem Effect

cloudless-api (foundation)
├── lambda-shell-runtime (execution)
├── lambda-shell-layers (tools)
├── terraform-aws-* (infrastructure)  
└── http-cli (networking)

Each piece amplifies the others. The layers make shell scripts as powerful as any runtime while keeping them simple and composable.

Real-World Impact

Before layers:

  • Custom Dockerfile for every project
  • Rebuild tools from source each time
  • Large, slow-building images
  • Tool versions drift between projects

After layers:

  • Minimal runtime + optional layers
  • Pre-built, tested, versioned tools
  • Fast deployments, small images
  • Consistent tool versions across ecosystem

The Developer Experience

# Want QR codes in your API?
# Just add the layer - no Dockerfile changes needed

api_handler() {
    local text="$1"
    qrencode -o /tmp/qr.png "$text"
    echo '{"statusCode": 200, "body": "QR generated"}'
}

What We Built

  • qrencode - QR code generation (~150KB)
  • htmlq - HTML parsing (~2MB)
  • imagemagick - Image processing (planned)
  • pandoc - Document conversion (planned)
  • sqlite - Database engine (planned)

Each with:

  • Multi-stage Docker builds for static binaries
  • Automated build and test scripts
  • Clear documentation and examples
  • Terraform integration patterns

The Philosophy Realized

This embodies everything cloudless stands for:

Infrastructure that gets out of your way - Add tools without complexity Local tools, cloud scale - Same binaries work everywhere Composable, not monolithic - Pick exactly what you need No vendor lock-in - Standard Lambda layers, portable anywhere

The Network Effect

Each new layer makes the ecosystem more valuable:

  • More tools → more use cases
  • More use cases → more adoption
  • More adoption → more contributors
  • More contributors → better tools

What’s Next

The pattern is proven. Now we scale:

  • Build remaining planned layers
  • Document integration with cloudless-api
  • Create terraform modules for layer management
  • Enable community contributions

The Bigger Picture

This isn’t just about Lambda layers. It’s about composable thinking applied to infrastructure.

Break complex systems into simple, reusable pieces. Combine them to solve real problems. Own your stack.

Infrastructure Lego blocks - finally real.

The cloudless DNA is now complete.