Super fast builds with zero delay and no feature lock-in

Build/CI/CD as a service with no monthly subscription

Pay As You Go

Instead of paying monthly only pay for what you use. Billed by wall clock time

Super Fast

Using the fastest bare metal machines available, builds are triggered instantly via WebHooks

Unlimited Concurrency

Run as many builds as you like at the same time (within fair use policy)

How it Works

REST / WebHooks

All builds are triggered via WebHooks in the REST API. No polling


POSTed messages are piped into container via STDIN and CGI interface.

GitHub / BitBucket

We provide example Docker start stages that process the GitHib/BitBucket push event or fork them on GitHub


The Docker containers volume is used to declare the output of the build


Additional stages can be created by chaining together output volumes with other containers

S3 support / GitHub Release

We provide pre-built Docker end stages for releasing your binaries to your favorite repository or fork them on GitHub.


3 stages: checkout from GitHub, run a build command and release to GitHub

A developer pushes to GitHub

This could be any VCS that supports WebHooks or commit hooks.

$ git push
Counting objects: 3, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (3/3), done.

GitHub WebHook is triggered

It sends a POST request to our API

POST /p/{username}/{pipeline} HTTP/1.1
Host: api.10second.build
Content-type: application/json

  "ref": "refs/heads/master",
  "after": "13c3f0831b21aaa4e81917d6f683c6faca47f8cf",
  "repository": {
    "clone_url": "https://github.com/{user}/{project}.git",

Our API starts the GitHub checkout stage

Our API pipes the JSON data into standard input of the Docker process and sets various CGI environment variables. In this example Docker image it uses jq to extract data and pass the correct arguments to git. This is the standard output from the process:

Repository: https://github.com/{user}/{project}.git
Cloning into '.'...
remote: Counting objects: 26563, done.
remote: Compressing objects: 100% (10/10), done.
remote: Total 26563 (delta 3), reused 0 (delta 0), pack-reused 26553
Checking out SHA1: 13c3f0831b21aaa4e81917d6f683c6faca47f8cf

The result is we have turned the GitHub push event into the exact SHA1 checkout, you could use this method to support any VCS you like very easily. For example if you are using CVS you could add a commit hook that posted to our API

If Docker process exits with 0 then next stage is run...

Next we run the build stage

It doesn't really matter what the build command is as you can install any dependencies you wish inside the Docker image.

build: class com.googlecode.jcompilo.convention.AutoBuild

   [delete] Deleting directory: /data/10second.build/checkout/build/artifacts


The result will be some binaries (Jar files in this example) in a Docker volume and the console.log. Again the next stage is only trigger on a zero exit code

Finally we release to GitHub

This final step takes the binaries and uploads them on the GitHub release page

Creating release 2.197 ...
Release id: 1957965
Uploading artifact {project}-{version}.jar...

And that's it, each stage is just another process that is chained together similar to Unix pipes or chain loading. The only real difference is that we wait for each process to exit before passing the output from one to another.


Common Questions


Billed by wall clock time


Always free

  • Builds under 10 seconds are free
  • First 10 minutes usage are free
  • Super fast bare metal builds
  • No credit card required

Sign Up


The magic that makes this possible



Provides secure hypervisor isolation with great performance and minimal attack surface.



Uses Docker containers for repeatable build stages and unlimited customisation.



A Premium Bare Metal Cloud Provider with super fast machines and minimal deploy fuss.

Sign up

Enter your email to be notified of availability