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.
Many DevOps tasks can be solved in seconds if you can create VMs quickly:
We integrate seamlessly with GitHub and GitLab. Getting a “hello world” VM created only takes about five minutes:
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
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.
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.
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:
You can easily set up Layer in three steps:
We’ve built a simple full-stack chat messaging example based on Slack. It includes three layerfiles:
Run e2e tests on every commit:
Per-commit demo environments:
Build and push Docker images:
There are a few ways of thinking about these files named ‘Layerfile’:
# Start with an ubuntu base image
# 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
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.