The Depot API lets you build and push containers straight from your Go code. No Docker CLI. No scripts. Just fast, native builds triggered by a few lines of Go.

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.

We had a major outage on May 8th that took our core provisioning system for builds offline for several hours. This was a major incident that disrupted thousands of builds across Depot. We wanted to share some insights into what happened, how we fixed it, and what we're doing to prevent it in the future.

Self-hosting GitHub Actions runners isn't the "set it and forget it" option that folks may think it is. In this post, we will dive into why that is the case, and what the hidden costs are.

Often touted as a method for decreasing Docker image build times, COPY --link is actually more likely to have the opposite effect. Here's why.

We're excited to announce that Depot now integrates with Tailscale, enabling secure, identity-driven access to your devices, services, and cloud networks. Learn how to connect to your Tailscale tailnet with Depot.

Leverage .dockerignore, smaller base images, cache mounts, and multi-stage builds to drastically reduce the size of your Docker images.

Learn how to build and store your integration test builds once, and then pull them for multiple workflows as needed.

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

Compiling Rust in GitHub Actions can be slow in unpredictable ways. Let's examine the underlying causes and explore sccache as an effective solution.

We're excited to announce our newest release, Depot Registry! We've converted our old registry into a new, faster, and more powerful registry that is now available to all users.

Go 1.24 introduces external caching, allowing the compiler to offload cache management to an external program. This fine-grained approach improves build efficiency. Here’s how it works under the hood.

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

We are excited to announce an upgrade to Depot-managed macOS GitHub Actions runners that greatly accelerates disk I/O for all macOS jobs.

Staff Software Engineer Iris Scholten shares what it's like onboarding to a technical product, and how to implement and measure the impact of team-level Developer Experience initiatives.

Any project that reaches a certain size will eventually be slow to build. With Bazel, you can accelerate your builds by using a remote cache to compile dependencies once and share them across your environments, like CI pipelines or your local development environment.

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

The next evolution of build cache is remote. Learn how the adoption of remote build caching can significantly reduce build times and improve developer experience and productivity.

As JVM projects grow, build times slow. Gradle's incremental builds with remote caching speeds up development in all environments, CI and local alike.

We're excited to release new cache retention policies for your GitHub Actions and Depot cache. You can now set time and size limits for your cache entries to have better control over your cache storage costs.

Depot now supports larger builders for accelerated Docker image builds. You can now choose a Docker image builder with up to 64 CPUs and 128 GB of memory.

We're excited to announce that starting today you can run all your Dagger workloads on Depot through our accelerated GitHub Actions runners.

We're excited to kick off 2025 with our newest product, Depot Cache! This new product allows you to leverage our high performance remote cache to speed up builds for Bazel, Go, Gradle, Turborepo, sccache, and Pants.

Senior Software Engineer Dan Davidson reflects on breaking the programmer mold, embracing iterative workflows and DevEx frameworks, and navigating productivity, collaboration, and efficiency.

Let's break down how optimizing your builds with Depot will ultimately lower your CI spend by half.

Platform Engineer Annabelle Thomas Taylor shares her journey from software developer to DevOps engineer, exploring the shared and distinct DevEx challenges in both roles, from reducing friction in CI/CD to fostering flow and resilience during high-stress incidents.

Things don't always go as planned. Here's a look at what happened the first week of December that took our container builds offline twice and what we're doing to prevent it in the future.

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

Staff Engineer Nic Pegg shares his journey from navigating poor DevEx to spearheading initiatives that reduce friction, foster collaboration, and empower developers to thrive — both technically and emotionally.

What is a "tar" (tape archive) file? A deep dive into the history and inner workings of the tar file format to create better optimized archives.

We've rolled out two new settings you can now control for your organizations GitHub Actions runners to automatically authenticate with our Depot Registry and to default to using containerd inside of your workflows. Read on to learn more about these new settings.

Our thoughts on the origins of DevEx, the current state of affairs, and where DevEx research and practice might be headed.

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

We're excited to announce our new Developer Experience function, led by our Head of Developer Experience, Kristen Foster-Marks.

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.

Starting today, all Depot GitHub Actions runners are now Ultra Runners. We're excited to launch these new runners to make your GitHub Actions jobs up to 3x faster.

We're excited to announce that macOS GitHub Actions runners are now available on Depot! This means you can now run your macOS builds on Depot's infrastructure for faster builds at half the cost of GitHub-hosted runners.

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.

In this article, we explain what Docker buildx is, how it’s different from docker build, the extra functionality it offers, and when you should use it.

We love GitHub Actions, but the default runners are slow and expensive. We benchmarked the performance of GitHub Actions runners against Depot runners and found that Depot runners are 2x faster and half the cost.

Depot GitHub Actions runners with GPUs are now generally available for Depot Managed. This allows you to run the full data plane in your own AWS sub account with your own set of GPU resources.

Drowning in Docker clutter? Learn how to use docker system prune to reclaim valuable disk space and remove all those old artifacts that are hogging your machine.

Our latest iteration on Depot organization usage introduces new stats and better visibility across your organization, including analytics for GitHub Actions and storage usage.

Go beyond the Docker CLI with some of the best tools in the container ecosystem. We share our favorite Docker tools that we use every day.

Using Fly.io's new Depot builder, we'll walk you through how to deploy a TypeScript service globally with speed.

Dive into the world of Docker images, Dockerfiles, the docker build command, and much more. We'll cover the basics of Docker and how to get started with building Docker images.

We're excited to announce that starting today you can build your Fly.io applications with Depot, directly from flyctl!

GitHub Actions has several pain points like slow CPUs, slow networks, flaky caching, and odd billing practices. We built Depot GitHub Actions runners to solve these problems and make your builds faster, more reliable, and more affordable.

Docker multi-stage builds enable parallelization and reduce image size. This article shows examples of multi-stage Dockerfiles with in-depth details.

To learn what a Docker layer really is, we'll dissect a Docker image and take a look inside. Deep dive into the layers of a Docker image and understand how they work.

To build a Docker image quickly, you should make use of Docker's layer cache. Here we show how to use the layer cache in GitHub Actions.

You can now configure project level build timeouts for your container build projects and cancel builds from within Depot.

Now available for all organizations using Depot GitHub Actions Runners is the ability to view and delete cache entries from your GitHub Actions cache.

Speeding up a Docker build requires optimizing the Dockerfile, maximizing the use of the cache, and taking advantage of multiple architectures.

A comparison of the best CI providers for fast Docker builds, and an introduction to Depot, which gives speed improvements for your CI Docker builds.

A breakdown of different Docker artifacts and build cache items that take up disk space and how to prune them individually or clear them all locally and in CI.

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.

Now available inside Depot: a real-time visualization for monitoring your GitHub Actions Runners and Jobs leveraging our managed runners. Get a live view of all the jobs and runners running in your GitHub organization.

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.

Use Depot to build your Docker images and push them directly to a Fly registry for your app for even faster deployments.

Using a matrix strategy in GitHub Actions can help you parallelize your GitHub Actions jobs by definining a matrix configuration to run different variations of a job in parallel based on the matrix values.

Inside of Depot build insights you can now see what is in your Docker build context on every build. Knowing what is in your context can help you discover unexpected files your including in your build and final image.

Rust builds in Docker tend to be slow. This article shows how to drastically speed them up using Docker layer caching and more advanced techniques like sccache.

Bitbucket Pipelines can build Docker images, but not quickly. This post shows how to overcome the limitations of building Docker images in Bitbucket Pipelines.

Dive into how to build a customer container image with Depot and run a GitHub Actions job in it in the same workflow. Combine the power of accelerated Docker image builds, ephemeral registry, and Depot runners to optimize your workflows.

We're excited to share that you can now connect your Depot projects to Cycle.io for faster Docker image builds in less than 60 seconds. Here is how to get started.

We're excited to introduce our third product, GitHub Actions Runners accelerated by Depot. All of the speed and performance from Depot-backed Docker image builds, now for your GitHub Actions jobs.

We are happy to reveal that Depot is now SOC 2 compliant. This is a significant milestone for us, so we thought we would share some more details and what it means for you.

We're excited to announce that we've now made Depot ephemeral registries available to depot bake commands so that you can save built images for multiple targets for later use in your CI workflows, to share with your team, or to push to remote registries.

This article walks you through how to use Depot's API within your own code to set up projects and run your Docker builds as a service on Depot's infrastructure.

We're excited to announce that we've released a set of Dagger Functions for Depot. You can use them to offload any build or bake operation to Depot and use the built image in your own Dagger code via our ephemeral registry.

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.

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.

Knowing how to optimize your Docker image builds to leverage the build cache as often as possible is critical to making your builds fast. We'll show you how the layer cache works and how to use the cache efficiently, so you can get the most out of your builds.

We're excited to release Depot ephemeral registries that allow you to save built images for later use in your CI workflows, to share with your team, or to push to remote registries.

A deep dive into building Docker images in AWS CodeBuild and how you can build a Docker in CodeBuild with the Lambda compute type via Depot.

Building Docker images in GitLab CI comes with tradeoffs between security, complexity, and performance.

A detailed guide with suggestions on how to leverage Depot in your monorepo workflows so that you get effective caching and fast builds.

Optimizing for building Docker images in the cloud can help reduce image and build context size so that your builds can leverage the full power of Depot builders.

Building multi-platform, also known as multi-architecture, Docker images in GitHub Actions is becoming a necessity. See how to build them in GitHub Actions.

Depot is now available in the AWS Marketplace for customers looking to purchase an Enterprise plan via AWS.

We're excited to release the Dockerfile Explorer, a tool for introspecting the LLB output of BuildKit's Dockerfile parser.

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

Track your monthly Depot usage across your entire organization, and per-project, with stats for build time, error rate, cache performance, and more.

You can now generate a Software Bill of Materials (SBOM) for every build with Depot and access it directly from our new build Attestations view.

We're very excited to release our brand new build insights feature, which gives you better visibility into your builds and helps you debug issues faster.

Building Docker Arm images today usually means using emulation. But, it's slow and inefficient. See how to build multi-architecture images with zero emulation.

We've added the ability to lint Dockerfiles on demand in Depot. This post covers the top 10 most common Dockerfile linting issues we've seen flowing through Depot.

In addition to our existing GitHub Actions and Buildkite OIDC integrations via trust relationships, we now support CircleCI OIDC for Depot builds as well.

Organization owners can now configure usage caps to limit the total number of build minutes their team can use in a given month.

We're excited to announce that with our new configure-docker command, you can now use Depot to build the images in your Docker Compose file automatically without changing a single line of code.

We're excited to announce that Depot has joined the Cloud Native Computing Foundation (CNCF) as a silver member to help more folks learn about and use cloud native technologies like Depot.

Overmind leverages Dev Containers to manage and roll out a standard set of development tools and configurations to their engineering team. They switched to Depot to build their multi-platform Dev Container images 10x faster.

We're excited to bring a new feature to the depot CLI that allows you to configure docker build to use Depot for all image builds by default.

Our first Depot Drop Week is over! We announced three new features that are going to make builds even faster, easier to embed AI models into a build, and allow public forks to leverage the power of Depot builders.

Use ephemeral Depot builders to build and test Docker images on pull requests from forks of your open-source repositories with our new authentication mechanism for public forks.

A free open-source Docker registry for public AI models. Add any top 100 model on Hugging Face to your Dockerfile with a single COPY statement.

We're excited to announce our new cache storage architecture that makes builds even faster, eliminates project constraints, and allows you to choose the cache size that makes sense for your project.

Using the Docker build cache speeds up builds by reusing layers from previous builds. But sometimes you want to build an image without the cache. Here's how.

We're excited to bring our public API out of beta and make it generally available to all Depot customers. Learn more about what you can do with our new API and how to get started.

Windmill.dev switched to Depot for their native Intel & Arm Docker image builds, making them 13x faster inside of GitHub Actions.

See how you can accelerate your Docker image builds in CircleCI with Depot. Saving you time and credits with faster builds for native Intel & Arm images.

We're added a build summary link for every build and refreshed the build details UI to make it easier to see what's going on with your builds at a glance.

We're excited to announce that you can now lint your Dockerfile on every build with Depot! No more configuring a separate Dockerfile linter outside or before your build in CI.

There are four fundamentals to building a Docker image quickly with docker build. From the moment we create a Dockerfile, we should be thinking about the fundamentals of building a Docker image as fast as possible.

All of our documentation is now open source so that you can contribute to it if you'd like and so that we can improve on it in public.

Today we're announcing local Docker image builds with the speed of Depot's cloud builders and instant cache sharing across your entire team.

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

We've launched a new integration that allows you to build container images faster with Depot directly from your existing Buildkite pipelines.

See how much of your builds are cached and how much time that saves you and your team. In addition, monitor how much provisioned cache you are using for each build architecture.

Fast image builds just got even faster with the introduction of bigger builder machines that have 4x the compute power.

With CLI version 1.5.0, buildx bake comes to Depot via the depot bake command. Build multiple Docker images concurrently from an HCL, JSON, or Docker Compose file.

BuildKit cache mounts provide a more fine-grained cache that allows you to leverage pre-computed work even when the Docker layer cache invalidates.

Building your Docker images just got even faster with the ability to launch Depot builders in the region closest to your registries.

The easiest way to get faster Docker image builds inside of Google Cloud Build is to make use of the layer cache as frequently as possible. But options available today in Cloud Build can often negate the advantages of layer caching.

If you use the asdf version manager, you can now add our Depot CLI as a plugin to manage all of your versions in one place.

We made it even easier to sign up and try out Depot by adding support for logging in with Google and Microsoft accounts.

Self-hosted Depot builders are here! Launch builders in your own AWS accounts on a per-project basis and connect directly to them without passing through any Depot proxy.

Reducing the overall image size is key to building and launching Docker images as quickly as possible. The smaller the image size, the less network bandwidth we have to consume to build and launch it.

You can now authenticate to Depot with a project-specific API token, for fine-grained access control over your Docker builds.

Writing a Dockerfile that builds quickly involves understanding the Docker layer cache and working with it to maximize the number of cache hits between builds.

Building Arm and multi-architecture containers today is challenging. In this post, we explore the current options and how Depot addresses each challenge.

Depot is a new container build service with blazing fast compute and persistent caching, for both Intel and Arm containers.