AWS Lambda durable functions let you write long-running processes that survive crashes and suspend compute entirely while waiting for external events. Getting them right requires understanding how replay works and the distinct failure modes of durable functions. Here's what we've learned from running durable functions for real.

We had a standby pool algorithm with over a dozen tunable parameters and no good way to test changes without risking real customer latency. So we built a simulator fed with real job data, ran hyperparameter optimization on it, and found a configuration that was faster and cheaper.

microVMs are everywhere in 2026, especially for CI and sandboxes. But when you're building a platform, choosing between QEMU microvm and cloud-hypervisor isn't obvious. We compare API support, GPU passthrough, snapshotting, live migration, and hotplugging.

We built a fun Spotify Wrapped-style recap for Depot customers. Handling a year of data and making big numbers relatable was easy compared to teaching AI that "0.1 of a marathon" isn't exactly celebratory.

Optimizing GitHub Actions without telemetry is guesswork. We built CI telemetry into Depot to surface real metrics for every job, like CPU, memory, and logs. Here's how we wired it together with OpenTelemetry and scaled it with ClickHouse.

We ran iOS builds across different EBS disk configurations on EC2 macOS instances to find the optimal setup. We discovered that simply throwing more IOPS at the problem doesn't work the way you'd expect.

When upstream systems fail, retries pile up fast and your database becomes the bottleneck. Here's how we used PlanetScale's Insights to identify and fix the queries that were slowing us down during thundering herd events.

BuildKit's DAG solver transforms your Dockerfile into an optimized execution plan, finding every opportunity to run things in parallel. Learn how stage parallelism, instruction parallelism, and work deduplication combine to dramatically speed up your container builds.

We analyzed over 60,000 checkout steps in GitHub Actions runners. 98.5% of organizations could be missing out on massive performance gains.

We analyzed 66,821 GitHub Actions workflow runs to uncover valuable third-party actions that teams are using to speed up CI pipelines and improve developer productivity. The data reveals hidden gems in the Actions marketplace that could transform your workflows.

Experiments with using Claude in Depot remote sandboxes to identify documentation gaps, generate drafts, and collaborate with your team on keeping docs up to date.

GitHub Actions Runners power every job you run, whether on GitHub-hosted machines or your own hardware. But the way they work and the APIs they talk to have been changing. In this first part of our deep dive, we unpack the Listener process, how it's evolved from Azure DevOps roots, and what those changes mean for anyone running or accelerating Actions with Depot.

Maintaining forks of rapidly-evolving upstream repositories is a productivity killer. At Depot, we were spending hours each week manually updating ARM64 patches and reviewing dozens of commits just to keep our GitHub Actions runner images in sync. Here's how we used Claude Code to automate the entire process, turning a weekly time sink into a hands-off CI workflow.

Many SaaS platforms need to run customer code securely and fast. Rather than building container infrastructure from scratch, you can use Depot's API to handle the heavy lifting. Here's how to build Go tooling that creates isolated projects, manages builds, and tracks metrics for your customer workloads.

We at Depot like making shit fast, whether that's Docker image builds, Github Actions runners, Bazel caching, Turborepo, or even our own infrastructure. Recently, we've been working to make EC2 instances boot faster.

How PlanetScale Metal accelerated our database query performance and allowed us to store extended build analytics data.

Learn how we’ve taken the time it takes for our infrastructure to launch GitHub Actions runners down to 5 seconds.

Learn how we dramatically reduced the tail latency (p99) of our GitHub Actions Runners initialization from 39 to 9 seconds by caching API schemas.

Depot joined Cloudflare at AWS re:Invent 2024 to discuss the challenges of observing serverless applications and how high-cardinality metrics + Baselime can help.

Optimizing containers to boot ultra-fast by lazily loading files with eStargz. Start your containers up to 76% faster.

Docker images are downloaded as compressed layers and default to gzip compression. But is there a better option? We compare gzip and zstd compression methods to see which is best for building and pushing images.

When your CI pipelines are slow, you can only optimize so much. Bottlenecks in CPU, Network, Memory, and Disk I/O can all contribute to slow CI pipelines. Let's take a look at how disk I/O can be a bottleneck in GitHub Actions.

We built out own custom Envoy discovery service to quickly add and remove BuildKit instances when running outside of AWS. Here is the full guide on how we did it.

It's possible to cut EC2 boot time from 40 seconds to 5 seconds by combining several optimizations like root volume streaming, instance warm pools, and instance resizing.

Here's how Depot reverse-engineered the GitHub Actions cache and built our own GitHub Actions Runners to achieve a 10x improvement in cache speed.

This article explains how BuildKit works in depth, why it's faster than Docker's previous build engine, and what it looks like under the hood.

We go behind the scenes into Depot's architecture to explore exactly how it delivers fast, secure, multi-platform Docker builds locally and in CI.

Exploring how OCI images represent layers, how layers can modify and delete files from previous layers, and how container runtimes combine layers into a single filesystem.

We're reducing time-to-start by optimizing EC2 instance boot time, infrastructure provisioning, and improving UI and CLI flows to reduce unnecessary steps.

A Kysely dialect for PlanetScale that allows you to write type-safe and autocompletion-friendly SQL queries.