PT Get started
Database changes, under control

Ship SQL to production the way you ship code

Sql2DevOps runs your SQL as versioned packages from development to production, with approvals, a tracked emergency path and a tamper-evident history your auditor can verify.

SQL Server · PostgreSQL · SQLite  ·  GitHub Actions, GitLab CI, Azure DevOps, Jenkins  ·  one binary for Windows, Linux and macOS

$ sql2devops promote CHG-1001 --project finance
CHG-1001 v1 (sha256:9f2c41e07b6a...) to PROD/finance-db
  step 1/3: 01-rates-table.sql (ddl) ............ ok  41 ms
  step 2/3: 02-interest-function.sql (other) .... ok  12 ms
  step 3/3: 03-initial-rates.sql (data) ......... ok   8 ms
succeeded · recorded as event #12 · signed by ci-runner (a1c94e0b72d3)
# approved by github:maria, after the same version succeeded in DEV and HML

Sound familiar?

Application code has pipelines, reviews and history. The database usually gets a script pasted into a console at 11 p.m.

"Did this run in production?"

Nobody knows which scripts reached which environment, in which order, or who ran them.

"It worked in staging"

Production received a slightly different script than the one that was tested.

"The fix was urgent"

Emergency changes skip every rule and are forgotten, until the next deployment breaks.

How it works

Three ideas: packages, promotion and a history nobody can quietly rewrite.

Package your change

A folder with your scripts, their order and their rollbacks. Submitting it stores an immutable copy with its hash.

package: CHG-1001
target: finance-db
steps:
  - file: 01-rates-table.sql
    rollback: rollback/01.sql

Promote it

The same version moves DEV → HML → PROD. Each environment has its own rule: no approval, the pipeline's evidence, or named people.

$ sql2devops promote CHG-1001
$ sql2devops approve CHG-1001 \
    --env PROD

Keep the proof

Every submission, approval and run is a signed, hash-chained event in your own Git repository. One command checks it was not altered.

$ sql2devops verify
consistent: 248 events,
2 projects, all signed

See everything at a glance

The web interface (paid edition) shows every package across your environments, what is waiting and why, each run with its steps and the exact line that failed.

Built for the day something goes wrong

Your scripts, your rules. Flexible by default, strict where you configure it, and everything recorded.

Failure reports that help

The script, batch and exact line, the server's message and the surrounding code, and the state the database was left in.

Rollbacks per step

On failure, the failed step and the completed ones are rolled back, newest first. Or stop and keep everything for analysis.

Emergencies, tracked

Bypass the rules when production is down, with a reason and a ticket. Follow-ups stay visible until reviewed and reconciled.

Your Git, your data

History lives in a Git repository you own. No server, no account, nothing sent to us.

Secrets stay secret

Passwords enter scripts as variables from your pipeline's secrets and are masked in every report.

One small binary

No JVM, no runtime. Download one file, or use the ready-made GitHub Action.

Simple pricing

Start free. When your team needs the whole thing, one flat price per company, not per user, not per database.

Free

$0
For developers and small projects
  • Executor for SQL Server, PostgreSQL, SQLite
  • Signed, verifiable history in your Git
  • Approvals and tracked emergencies
  • Packages with up to 2 scripts
  • Projects with up to 2 environments
  • Web interface
  • Email support
Download

Larger organizations, invoices or a yearly contract? Talk to us.

Get started in a minute

Install the binary, point it at a Git repository for the history, and run your first package.

# Windows (PowerShell)
PS> irm https://sql2devops.com/install.ps1 | iex

# Linux / macOS
$ curl -fsSL https://sql2devops.com/install.sh | sh

# GitHub Actions
- uses: sql2devops/setup@v1

Questions

Does Sql2DevOps check or rewrite my SQL?

No. It runs your scripts exactly as written, in the order you define, and reports precisely what happened. What the scripts do, and their rollbacks, is up to you.

Where is my data?

Nowhere but your own infrastructure. The history lives in a Git repository you own, and the tool never contacts our servers, not even to check the license.

Can I adopt it on an existing database?

Yes. Package your next change and start from there; scripts that already ran by hand can be recorded so later deployments know about them.

What happens when the license expires?

The free edition applies again. Limits are checked before anything runs, so a deployment is never interrupted halfway.

Is it open source?

The source is available under the Business Source License 1.1: you may use it in production, and each version becomes Apache 2.0 four years after release.