Depot CI runs GitHub Actions workflows on Depot infrastructure, and migrating is pretty seamless. Here's a walkthrough of moving an app's CI over, from installing the CLI to digging into logs.

The old CI debugging loop goes: edit YAML, commit, push, wait, squint at logs, repeat. Depot CI replaces that with a local loop you can actually control, from running workflows against uncommitted changes to SSHing into the runner mid-job.

Slow Docker builds are annoying and disrupt your flow. This guide shows practical techniques to optimize your Dockerfile, from simple instruction reordering to advanced caching strategies, with real measurements from a production-like Node.js application.

When graceful shutdown is an afterthought, it's one of the most common sources of production bugs. When servers restart, work gets dropped, state gets lost, and you end up chasing weird behavior at startup. Here's how to use contexts and WaitGroups to implement clean shutdowns that don't lose work or corrupt state.

Ever wondered when Docker reuses cached layers and when it rebuilds from scratch? This guide breaks down the mechanics of how caching works, how cache invalidation cascades through your builds, and how different instructions affect the cache.

Not every self-hosted runner failure is actually a runner problem. GitHub Actions and third-party actions often expect environmental features that GitHub-hosted runners provide by default. When your setup differs, you may get cryptic errors that point to the wrong cause. Here are three real support cases where the symptoms looked like runner issues but weren't.

Build a specialized container building system using Depot's low-level Go SDK to transform tar archives into container images. This advanced walkthrough demonstrates the three-step build flow: registering builds, acquiring ephemeral BuildKit machines, and configuring custom build solutions.

Building Rust projects in CI can be painfully slow, but with the right optimizations, you can dramatically reduce build times. We tested various techniques on the Zed codebase and achieved a 35% speedup over our already-optimized baseline, cutting build times from 27 minutes to just 16 minutes.

GitHub Actions are great when they just work, but a single failing job can bring everything to a halt. Sometimes the error is obvious, other times it feels like the runner is failing for reasons that have nothing to do with your code. This guide walks through practical ways to debug those failures so you can get builds running smoothly again.

Cache mounts let you preserve partial build state between Docker builds, making incremental rebuilds faster when layer cache misses. Here's how to use them effectively, avoid common pitfalls, and make them work reliably in CI environments.

Most engineering teams overspend on CI/CD by 50% or more. Here's how to cut your build costs in half without slowing down deployments.

GitHub Actions usage reporting doesn't tell the full story. If you're running different types of runners (like 4-core, 8-core, or more), those minutes aren't equal, and your total usage number doesn't reflect it.

A crash course into the new ability to run Claude Code agents in GitHub Actions and how to make them faster with Depot runners.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Building multiple Docker images sequentially wastes time and duplicates work. `docker buildx bake` lets you define all your builds in one file and run them in parallel, with BuildKit automatically deduplicating shared dependencies.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.