LayerCI is a cloud-hosted DevOps platform that creates newly provisioned VMs for every code change extremely efficiently. We monitor which files are used by which steps, and automatically skip any repetitive setup work.

What are LayerCI VMs useful for?

Many DevOps tasks can be solved in seconds if you can create a VM quickly:

  • Staging environments are ready in seconds because the new VM contains a new copy of the database that was set up last run.
  • It’s easy to run E2E tests in parallel if you can duplicate the entire test VM.
  • Build and push your container images effortlessly with the same version of Docker you use in production.

Is it hard to get started?

We integrate seamlessly with GitHub and GitLab. Getting a “hello world” VM created only takes about five minutes:

  1. Install LayerCI onto a repository of your choice.
  2. Create files named ‘Layerfile’ anywhere in your repository.
  3. Push your commit, we’ll immediately start building its Layerfiles in parallel.

You don’t have to replace your entire CI system. When you install LayerCI, it’ll show up as an extra status beside traditional CIs like CircleCI or GitLab CI in the pull request page.

Try an interactive tutorial

How is LayerCI different from a traditional cloud provider?

LayerCI is built as a DevOps platform, and not for hosting production code.

Our VMs use memory snapshotting to work like Docker containers. They’re faster and more developer-friendly than a traditional VM.

We can create dozens of VMs per branch, because we automatically hibernate them when they’re not in use.

Because the configuration looks like a Dockerfile, you don’t need to configure a complicated build process either.

You simply write a Layerfile (similar to a Dockerfile) and we’ll use memory snapshots to automatically reuse the work done the last time the pipeline ran.

How is LayerCI different from a traditional CI provider?

Traditional CI systems will only allow you to build artifacts and run unit tests - you can’t easily create a fresh copy of your entire backend to run meaningful tests.

LayerCI is meant to be as simple as a traditional “docker-build” CI system, but as powerful as provisioning a new VM from scratch.

How expensive is it?

For personal projects and small startups, free.

For larger teams, we charge a flat fee of $35/developer/month (when billed annually) to keep incentives aligned.

We don’t want to charge per build minute because that would incentivize us to slow things down for profit.


LayerCI is an all-in-one DevOps platform. We provide three main value propositions to our users:

  1. Run e2e tests on every commit.
  2. Collaborate more easily with per-PR staging environments.
  3. Set up CI/CD to build and deploy to production.


You can easily set up Layer in three steps:

  • Sign up.
  • Install Layer onto a relevant source code repository (e.g., GitHub).
  • Create a file named ‘Layerfile’ anywhere in your repository.

Start from our examples

We’ve built a simple full-stack chat messaging example based on Slack. It includes three layerfiles:

  1. Run e2e tests on every commit:

  2. Per-commit demo environments:

  3. Build and push Docker images:



There are a few ways of thinking about these files named ‘Layerfile’:

  1. As auto-discovered Dockerfiles that build entire virtual machines instead of containers, just as quickly.
  2. As a defined tree of virtual machines. Each subsequent layer can inherit all the running processes in its parents.
  3. As a trigger for specific actions: e.g. build, push, test, and deploy in parallel every time you push new code.

A minimal sample with cat

# Start with an ubuntu base image
FROM vm/ubuntu:18.04

# Copy the file named 'file' from the repository to the destination 'hello'
# in the continuous staging environment.
COPY file hello

# 'cat' is a unix directive that prints the contents of a file.
# You could just as easily run a script that runs tests, deploys, or starts a database.
RUN cat hello

How layers work

Behind the scenes, Layerfiles define a linear series of “layers” that stack on top of each other, starting at the top of the Layerfile.

Every 20 seconds, we’ll snapshot all the files and processes in the VM and store them for later.

In practice, this means that we’ll be able to avoid re-running repetitive steps such as database migrations for each push.

Unlike the Docker cache, we monitor all the files that are read by any process at the system level. We’ll only re-run a layer if we can’t find a previous one which agrees on your commit with the repository’s files.

Put expensive steps as high up in a Layerfile as possible, and we’ll skip as many steps as possible the next time you push code.