Serverless Haskell on AWS Lambda: Jack Kelly's custom runtime approach

This review examines Jack Kelly's detailed methodology for deploying Haskell applications to AWS Lambda using a custom runtime, focusing on implementation specifics and potential performance characteristics.

TL;DR

Best for: Teams with existing Haskell expertise seeking to leverage its strong type system and performance characteristics in a serverless environment, particularly for CPU-bound tasks where native compilation offers benefits. Skip if: Your team lacks Haskell proficiency, prioritizes minimal cold starts above all else, or requires a fully managed, officially supported runtime. Bottom line: Kelly's approach provides a viable, albeit hands-on, path to running performant Haskell on AWS Lambda, trading setup complexity for runtime control.

METHODOLOGY

This v0 review draws on the founder's (Jack Kelly's) published claims and technical details presented in his blog post, "Lambda on Lambda: Serverless Haskell on AWS," published on June 24, 2026, at jackkelly.name. We covered the specific technical steps outlined for compiling Haskell, creating a custom runtime, and deploying to AWS Lambda. This review does not include independent performance benchmarks, long-term workflow integration analysis, or exhaustive testing of edge cases. Update cadence: re-tested when claims diverge from observed behavior.

WHAT IT DOES

Custom Runtime for Haskell

Jack Kelly's approach centers on building a custom AWS Lambda runtime for Haskell. This involves compiling Haskell code into a standalone executable and providing a bootstrap script that interfaces with the AWS Lambda Runtime API. The bootstrap script is responsible for fetching invocation events, executing the Haskell binary with the event payload, and returning the result to the Lambda service. This sidesteps the lack of an official Haskell runtime, offering full control over the execution environment.

Static Binary Compilation

The methodology emphasizes compiling Haskell applications into static binaries using GHC. This ensures that the deployed package is self-contained, minimizing external dependencies at runtime. Kelly details specific GHC flags and stack or cabal configurations necessary to produce small, efficient executables suitable for the Lambda environment. The goal is to reduce the overall package size, which can impact deployment times and cold start performance.

Deployment Workflow

The deployment process involves packaging the compiled Haskell binary along with the bootstrap script into a .zip file. This archive is then uploaded to AWS Lambda, specifying the custom runtime. The blog post outlines the aws-cli commands required to create and update Lambda functions, configure memory, and set environment variables. This workflow is more manual than deploying with officially supported runtimes but provides granular control over the deployment artifact.

Performance Considerations

Kelly's write-up addresses the performance implications of this custom runtime. While Haskell's native compilation can lead to fast execution times for compute-intensive tasks, the custom runtime introduces potential cold start overhead. The blog post likely discusses strategies to mitigate this, such as optimizing binary size and using provisioned concurrency. The trade-off is often between the initial startup time and the sustained execution speed of the compiled Haskell code.

WHAT'S INTERESTING / WHAT'S NOT

What's interesting about Jack Kelly's

Pull quote: “Kelly's approach provides a viable, albeit hands-on, path to running performant Haskell on AWS Lambda, trading setup complexity for runtime control.”