Early development, pre-release

Backups you have proven you can restore

Sard is a backup console for the mixed infrastructure of small and mid-sized businesses, built for the integrators and MSPs who look after it. One screen answers the main question: can you restore right now, and if not, where did the thread break.

sardadmin

Overview

Last verified restore

3 h agoVerified

shop-db was restored in a sandbox and the data matched the source. Level 5 of 5, the restore took 2 min 14 s.

2failed
1no report
3backup, not verified
3verified

Needs attention

5 problems, the oldest first
crm-dbNo report for 26 hThe backup was due yesterday at 02:00. Agent web2 has been offline since Oct 23, 10:1226 h
media-filesBackup failed: 0 bytes left on the agent’s diskrestic could not write its cache to /var/cache/sard. Free up space on web2 or change the cache directory2 h
billing-dbRestore verification failedLevel 3 of 5: pg_restore did not find the role billing_ro. The backup itself exists3 h
web2Agent offlineLast connected Oct 23, 10:12. 3 sources depend on it26 h
db1The agent’s certificate expires in 21 daysRenewal failed: agent version 0.0.1 cannot renew. Update the agentNov 14
What the console looks like (an illustration, the data is made up)

A console that does not lie about success

  • A verified restore is the main metric

    Green does not mean “the backup ran”, it means “we restored from it”. No verification, no green.

  • Silence is a signal too

    A report that did not arrive on time is its own status, “No report”, not “OK”. Success is never shown by default.

  • State over decoration

    A dense instrument panel: the failing source is visible in a second. A status is always told by icon, text and color, never by color alone.

Sources by status, not by list

Sources with problems come first. A status is computed from the last backup and the last restore verification: green only where the restore is actually proven.

StatusSourceLast backupRestore verificationSchedule
Failed
media-files
Files on web2 → s3:offsite
Failed 2 h ago
No space on the agent’s disk
Verified 2 days ago
Level 4 of 4
Every day at 02:00
Next in 13 h
Failed
billing-db
PostgreSQL on db1 → s3:offsite
3 h ago · 4.2 GB
+38 MB since the last
Failed 3 h ago
Stopped at level 3 of 5
Every 6 h
Next in 2 h 40 min
No report
crm-db
PostgreSQL on web2 → local
26 h ago
Due yesterday at 02:00
Verified 2 days ago
Level 5 of 5
Every day at 02:00
Agent offline
Backup exists
erp-pg
PostgreSQL on db2 → sftp:nas
1 h ago · 18.6 GB
+412 MB since the last
Verification running
Level 2 of 5, 1 min 12 s
Every 4 h
Next in 3 h
Backup exists
home-dirs
Files on db2 → sftp:nas
9 h ago · 63 GB
Partial: 3 files not read
Not verified yet
First verification today at 04:30
Every day at 01:00
Next in 12 h
Verified
shop-db
PostgreSQL on db2 → sftp:nas
4 h ago · 2.9 GB
+7 MB since the last
Verified 3 h ago
Level 5 of 5 · 2 min 14 s
Every 6 h
Next in 2 h
Verified
sard-dbSard
PostgreSQL on sard-self → s3:self
5 h ago · 41 MB
Sard’s own database
Verified yesterday
Level 5 of 5 · 9 s
Every day at 03:00
Next in 14 h
Paused
legacy-ftp
Files on web2 → local
41 days ago
Schedule turned off Sep 13
—
Off
An illustration: the data is made up.

How it works

Sard orchestrates backups; restic does storage, deduplication and encryption. Backup data never passes through the server.

  • The agent dials out

    The agent is a gRPC client over mTLS. Hosts open no inbound ports.

  • Data skips the server

    The agent streams the backup straight to storage through restic. The server holds only control.

  • Sources are plugins

    Every source implements one interface: prepare → dump → stream → verify. The SDK is Apache-2.0.

Restore verification: a separate agent proves the backup restores

A verifier on another machine pulls the snapshot from the repository, restores it in an isolated sandbox and compares the copy with the fingerprint taken at backup. The “Verified” status appears only after that.

What is checked

  1. Level 1Storage integrityrestic check reading a part of the data
  2. Level 2Restorerestic restore --verify or pg_restore in a sandbox
  3. Level 3Startthe copy opens in its own application
  4. Level 4Meaning of the datathe copy’s fingerprint matches the source’s fingerprint
  5. Level 5Restore timeall stages passed and the restore time measured

Five outcomes, not two

Passed, failed, cannot verify, infrastructure failure, cancelled. A failure of the check itself is not passed off as a bad backup, and a failed restore is not passed off as a warning.

Today PostgreSQL (pg_dump) and file backups are verified. Verification runs as a daily scheduled cycle and on demand from the console. For databases the verifier needs Docker or Podman.

How verification works

What works today

Sard is in early development and not production-ready. An honest list of what exists and what does not yet.

Works today

  • Backs up files and directories
  • Backs up PostgreSQL: pg_dump in custom format plus the cluster’s roles and tablespaces
  • Stores backups with restic in S3-compatible storage, over SFTP or on a local disk
  • Runs on a cron schedule in a chosen time zone, with one catch-up run after downtime, or on demand from the console
  • Reports runs and missed schedules to Telegram
  • Installs agents from the server: deb, rpm and tar.gz for Linux amd64 and arm64, signed releases
  • Automatic restore verification: a verifier on a separate machine restores a snapshot in a sandbox and compares it with the source’s fingerprint (PostgreSQL and files)
  • Restore from the console into a new place: files and PostgreSQL databases
  • Backs itself up: its database, CA keys and configuration go nightly into a repository of your choice
  • Recovery of the Sard server itself by a page of commands that CI drills run
  • Prometheus metrics, retention of the server’s records, automatic renewal of agent certificates
  • Run cancellation, step timeouts, waiting for an offline agent
  • A console in Russian and English, dark and light themes, a printable recovery card
  • Install without internet: an image archive, signatures and SBOMs in every release

Not yet

  • Restore over existing data from the console (today: into a new place only)
  • Other sources: MySQL, network devices, 1C
  • More than one tenant
  • sardctl commands beyond version

The roadmap is a plan, not a promise. Read the roadmap

Plans

The open core is free and runs without enterprise modules. Enterprise is switched on by a license key, and the key decides the edition: Pro or MSP. The enterprise features are planned and not in the product yet.

  • Community

    The open core, AGPL-3.0

    Free

    • Backs up files and PostgreSQL with restic (S3, SFTP, disk)Available now
    • Schedules, on-demand runs, Telegram reportsAvailable now
    • Agents over mTLS, install from the server, signed releasesAvailable now
    • Automatic restore verification: PostgreSQL and filesAvailable now
    • Restore from the console into a new placeAvailable now
    • Backup of Sard itselfAvailable now
    • One administrator, one tenantAvailable now
    • Restore from the console over existing dataPlanned
    • New sources: 1C on PostgreSQL, MikroTik, Eltex, MySQLPlanned
    Set it up
  • Pro

    For a single organization

    Terms on request

    No tenant management, and the number of users is limited by agreement. Resale is not allowed.

    • Everything in CommunityAvailable now
    • SSO and RBAC: users, roles, sign-in through an external IdPPlanned
    • Audit logPlanned
    • Reports: RPO, RTO, statistics of restores, storages and backupsPlanned
    • LLM integration: anomaly analysis, help with administration and with writing verification scriptsPlanned
    • Enterprise-grade pluginsPlanned
    • External CA and certification (Vault, PKCS#11, GOST)Planned
    Contact us
  • MSP

    For integrators and MSPs

    Terms on request

    Allows providing the service to clients.

    • Everything in ProAvailable now
    • Tenant management: many clients in one installationPlanned
    Contact us

A server in 10 minutes

You need a Linux host (amd64 or arm64) with Docker Engine 26.0+, the Compose plugin 2.26+ and curl. The commands run sard-server and PostgreSQL from the published image.

SARD_TAG=v0.1.0-beta.1
mkdir -p ~/sard && cd ~/sard
curl -fsSLO "https://github.com/Artur-Abalov/Sard/releases/download/$SARD_TAG/docker-compose.yml"
curl -fsSL -o .env "https://github.com/Artur-Abalov/Sard/releases/download/$SARD_TAG/sard.env.example"
mkdir -p db
curl -fsSL -o db/db-init.sh "https://github.com/Artur-Abalov/Sard/releases/download/$SARD_TAG/db-init.sh"
curl -fsSL -o db/bootstrap.sql "https://github.com/Artur-Abalov/Sard/releases/download/$SARD_TAG/bootstrap.sql"
curl -fsSL -o db/pg_hba.conf "https://github.com/Artur-Abalov/Sard/releases/download/$SARD_TAG/pg_hba.conf"
curl -fsSL -o db/postgres-entrypoint.sh "https://github.com/Artur-Abalov/Sard/releases/download/$SARD_TAG/postgres-entrypoint.sh"
sudo chgrp 10001 .env && chmod 640 .env
docker compose up -d --wait
curl -fsS http://localhost:8080/api/v1/status

The first start asks for the administrator password in the console: a one-time code is printed in the server log, and the setup wizard walks you through the CA and the backup of the server itself.

The server is a control plane, not a key holder

Repositories, secrets and scripts are defined on the agent host and referenced by name only. Keys, credentials and script paths never cross the wire: the server holds no storage keys. Releases are signed (minisign, cosign) and carry SBOMs and build provenance.

Security and release verification

Open core

The server, agent, CLI and web UI are AGPL-3.0. The gRPC contracts and the plugin SDK are Apache-2.0, so third-party plugins, proprietary ones included, can be written without AGPL obligations. The open core runs without enterprise modules.

Contributing