Deployment.sh

Continuous deployment software that fits the CI you already have

Continuous deployment means every change that passes your tests reaches production without anyone typing a command. Deployment is the delivery half of that pipeline: your CI runs the tests, then calls one webhook or one CLI command, and Deployment ships the commit to your own servers with a health check, an atomic switch and a rollback ready.

Backend developer at a desk at night watching deploy logs scroll in a dark terminal on two monitors

Where most CD pipelines break

CI tools are excellent at building and testing. They are less good at the last step, the one that touches production servers. Teams end up storing SSH keys as CI secrets, maintaining rsync and restart scripts in YAML, and debugging deploys from CI logs that disappear after a few weeks. Each repository has its own variant, and nobody can answer which commit is live on which server without opening a terminal.

Split the pipeline where it belongs

With Deployment, CI keeps doing what it is good at and hands over a single, auditable request.

  • CI builds and tests the commit
  • CI calls the deploy webhook or runs the CLI with the commit SHA
  • Deployment clones that commit into a new release folder on each target server
  • The build runs, a health check confirms the release answers
  • The symlink switches, workers restart, and the result goes back to CI and to your alerts

No SSH keys live in CI. The token that triggers a deploy can only deploy, and only the sites you scope it to.

Developer sketching branch lines on a window with a grease pencil in a cramped loft workspace at night, laptop and bike in the background

Continuous deployment with GitHub Actions

Add a deploy token as a repository secret and call the deploy URL at the end of your workflow. The request waits for the result when you pass wait=true, so a failed deploy fails the job.

yaml 
name: test-and-deploy
on:
  push:
    branches: [main]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm test
  deploy:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - run: |
          curl -fsS -X POST "https://deployment.sh/api/v1/sites/${{ vars.SITE_ID }}/deployments?wait=true" \
            -H "Authorization: Bearer ${{ secrets.DEPLOYMENT_TOKEN }}" \
            -d commit="${{ github.sha }}"

Continuous deployment with GitLab CI

The same idea in GitLab CI, using the Deployment CLI in a small job that runs only on the default branch.

Bitbucket Pipelines, Jenkins, CircleCI and any other runner work the same way, because the trigger is a plain HTTPS request or a single binary.

yaml 
stages: [test, deploy]
test:
  stage: test
  script:
    - pip install -r requirements.txt
    - pytest
deploy:
  stage: deploy
  rules:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
  script:
    - curl -fsSL https://deployment.sh/cli/install.sh | sh
    - deployment deploy --site web --env production --commit "$CI_COMMIT_SHA" --wait

Continuous deployment without a CI server

Not every project has a test suite in CI. For those, Deployment's push webhook is enough: a push to the production branch deploys automatically, as explained on deploy from git. You can add a manual approval step for production so pushes to main wait for a click in the panel.

Environments, promotions and approvals

  • Branch per environment, with separate variables, domains and workers
  • Optional approval before production deploys, recorded in the audit log
  • Deploy the exact commit that passed staging to production from the panel or the API
  • Encrypted environment variables with a diff shown before the deploy runs

Feedback after every deploy

Deploy results go where your team already looks. Outgoing webhooks post deploy started, succeeded, failed and rolled back events to your own endpoints, and alerts reach Slack, Discord or email. The full log stays in the panel for 14 days on Starter up to 2 years on Enterprise. All endpoints are documented on the deployment api page.

Safe releases on every push

Continuous deployment is only comfortable when a bad deploy cannot take the site down. Atomic releases, health checks before the switch, worker restarts and one-click rollback are described on zero downtime deployment.

Continuous deployment for any stack

Laravel and PHP, Node.js and Next.js, Django and FastAPI, Rails, Go, Spring Boot, .NET, static sites and Docker. One pipeline pattern, one place to see what is live.

Which plan fits your pipeline

All plans include the deploy webhook, CLI and API. Starter is 49 USD a month (24 USD billed yearly). Team is 199 USD a month (99 USD yearly) and adds roles and the audit log your approvals need. Agency is 499 USD a month (249 USD yearly). Enterprise is 1 499 USD a month (749 USD yearly) with SSO. Compare them on PaaS pricing.

See pricing

Do I need to store SSH keys in my CI?

No. CI only holds a scoped Deployment token. Deployment reaches your servers with its own per-server key.

Can a failed deploy fail my CI job?

Yes. Call the API with wait=true or the CLI with --wait, and the command exits with an error when the deploy or health check fails.

Can I deploy to several servers in one run?

Yes. A site with several servers deploys to all of them and switches only when every server has built the release.

Can I try Deployment before I pay?

Yes, with the free one-time demo on the home page. Plans start at 49 USD a month, or 24 USD a month billed yearly.

Close the loop from commit to production

Connect a server, add one step to your CI and let every green build ship itself.

Want to see the deploy plan first? Try the demo.