Production environments are backed up without you doing anything. You restore a backup under Backups on the environment.
What is copied
- The database.
- The files your application has written: uploads, generated exports, anything under the directories that survive a release. The caches it rebuilds itself are left out.
- InfluxDB's data, where the environment runs it.
- A Valkey or Redis kept as a store, where the environment runs one:
VALKEY_PERSISTENCEorREDIS_PERSISTENCEatstore, see Valkey.
Your code is not backed up: it is already in git and in a build artifact.
Files left out
The caches your framework writes and makes again on its own are not copied:
| Application | Left out |
|---|---|
| Drupal | what is in css, js, styles and php/twig under web/sites/default/files |
| Laravel | what is in storage/framework/cache and storage/framework/views |
| Rails | what is in tmp |
A restore empties them, and the application fills them again as pages are asked for.
To leave out more, list anything your site can make again in vallic.yaml. On
a Drupal site:
backup:
exclude:
- web/sites/default/files/backup_migrate
- private/exports/*.csv
- Write each path as your application sees it, from the root of the repository.
- Keep it inside a directory the platform keeps across releases: your framework's uploads and private directory, and your mounts. A deploy refuses any other path: nothing outside them is backed up.
*matches within one name and**across any number of directories.
A restore leaves what you exclude alone: it is not put back and not removed.
Where a copy goes
| Copy | Where |
|---|---|
| Near | object storage (Cloudflare R2) on the same continent as your machines |
| Cold | a different provider, in the EU: Scaleway, in Paris |
| On the machine | the database only, for the last two days |
The cold copy recently moved from Hetzner in Helsinki. Until the Scaleway one holds enough history, both are written.
The copy on the machine keeps everything from the last 48 hours and never fewer than the three most recent. A restore reads from it first.
Once the disk it shares with your database is 90% full, or has less than 1 GB free, the copy on the machine is not written. The backup says so as a failed step, and the offsite copies are written as usual. The environment's Storage tab shows what the copy on the machine takes.
Keeping a copy of your own
Under Backups on your team, you can point backups at storage you control as well.
- Add the storage under Integrations, once: S3-compatible object storage, an SFTP host or an rclone remote. On S3, give it the bucket backups should go in, and a destination appears on its own.
- Otherwise, add a destination under Backups and pick the integration. It asks for a name and nothing else.
Rotating a key on the integration fixes every backup that uses it.
An rclone remote is its section of an rclone config file, pasted as rclone
writes it, and a location in it as remote:path. Rules:
- Kinds:
s3,b2,azureblob,google cloud storage,swift,sftp,webdav,ftp,dropbox,drive,onedrive,box,pcloud,storjandmega. Ask support for another. - Each setting is one line,
name = value, with the name in lower case. - Credentials are in the configuration itself. A setting that names a
file or a program (
key_file,service_account_file,ssh, anything ending in_command) is refused, and so isenv_auth = true: usekey_pem,service_account_credentials, or the keys themselves.
This is additive: we keep our copies as well. Your own storage is also how non-production environments get backed up offsite. It takes every environment of the team except those on the entry line of machines, where it is not offered.
When they run
Backups run once a day, in a two-hour window at night: 03:00–05:00 in the country your team is billed in. A team with no billing address yet is backed up at 05:00–07:00 local to the continent its machines are on.
To choose the hour and timezone yourself, use Backups → Backup / maintenance schedule on the project's Configuration page. One window covers every environment of the project. Scheduled maintenance on your machines is done in the same window: upgrades that restart a service.
The database can be copied every four hours instead. That is an add-on on production, on either plan and either shape, bought under Commercial terms. Files, InfluxDB and the cache stay once a day. The extra dumps are kept for a week.
With point-in-time recovery, the database's own log is copied every five minutes as well.
A missed backup runs as soon as it is noticed. Set a notification for a backup that keeps failing: nothing else notices until somebody needs to restore.
What is kept
| Production | Staging | Development | |
|---|---|---|---|
| Daily | 4 | 3 | 1 |
The same on either plan, shared or dedicated. How far back a series reaches is bought for production, and changed whenever you like under Commercial terms on the project's configuration page. Thirty days instead of four keeps a snapshot for each of the last thirty days, with a weekly and a monthly alongside.
The staging and development counts apply where those environments have a backup at all: on your own storage, or the database copy on their machine. See Non-production environments.
A backup you take by hand is kept for 30 days, regardless of the counts above.
Non-production environments
We do not back up staging or development offsite. They keep the database copy on their own machine. To back them up offsite, connect your own storage.
Restoring
Anything written since the snapshot is lost: a restore replaces what is there now.
Use Backups → Restore a snapshot on the environment. It asks you to confirm.
Two things stay as they are:
- the environment's logs on the machine
- the paths your
vallic.yamlleaves out of backups
Production can only be restored from its own history.
InfluxDB and a cache are put back from the environment's own history only. InfluxDB's restore replaces its data, and its users and tokens, with the snapshot's. A cache is stopped for the seconds its data takes to swap, and starts again holding the snapshot.
Restoring to a moment
With point-in-time recovery, production's database can be put back as it was at any moment of the last seven days, to the second.
Visitors get an error page while the database is rebuilt: the application and its workers are stopped.
Use Backups → Restore to a moment on the environment. The page shows the range within reach, from the oldest backup a moment can start from until now. The date picker only offers that range. Name the moment in your own time zone.
The restore takes as long as restoring the backup plus replaying the log: about half a minute for a small site, longer for a large, busy database. Files are not touched: they come back from the snapshots above. A fresh backup is taken as soon as the restore finishes, before the application starts again.
Point-in-time recovery is bought for production under Commercial terms, beside the cadence. It costs 25% of what the machines cost, extras aside, and at least €50 a month (£45, $62.50). Turning it on or off restarts the database once. It needs MariaDB, MySQL or PostgreSQL, so a stack without a database cannot choose it.
Every five minutes the database's own log is copied off the machine, to the same encrypted repository as the nightly backups. That is the binary log on MariaDB and MySQL, and the WAL on PostgreSQL.
What it can and cannot reach:
- Any second, while the machine is running. A moment one minute ago is as reachable as one six days ago.
- Up to the last copy of the log, if the machine itself is lost. At most five minutes of changes are gone. The Backups page shows when the last copy was made.
- The last seven days, from the first backup after it was turned on. That backup is the nightly one, or one you take by hand. Older than seven days, a restore lands on one of the snapshots that were taken.
- A long gap. If the log cannot be copied, the machine keeps it: a day on MariaDB and MySQL, two on PostgreSQL. The next copy that succeeds picks up everything it missed. Only a longer failure leaves a gap, and moments after it can be reached again from the next daily backup. You are told when copying fails, and so are we.
- Production, in place. A moment is restored into the same environment, never into staging. To read a past state somewhere else, restore a snapshot there.
- After a restore to a moment. Moments before the one you restored to stay within reach. On PostgreSQL, the ones between it and the restore itself may not.
The encryption key
Every repository is encrypted, and each one has a key of its own. A repository is one environment at one destination: an environment writing to three places has three unrelated keys.
The key is generated when the repository is first created, 256 bits from the system's random source, and stored encrypted. It is handed to a machine only for the job that needs it and never written to a task record.
Losing it makes that repository unreadable, by you, by us, by anyone. It is the same key for the life of the backups.
Taking it with you
Where the destination is your own storage, the team's Backups page
lists every repository on it, with Show the key beside each. With your own
credentials and the key you can restore anywhere without us:
restic -r <repository> restore.
Showing the key takes an Admin or the Owner, not anybody who can restore. It decrypts every snapshot in that repository, including ones taken before you joined the team. It cannot be changed afterwards: somebody who leaves the team keeps it.
On the platform's own destinations the key is not offered: it would unlock storage you cannot reach. Use an export there, or bring your own destination, which is the recommended arrangement.
Taking a copy out
What comes out is unencrypted.
Backups → Prepare a download turns one snapshot into a plain copy and
gives you a URL to it. It asks you to confirm before the copy is made. The
copy is a database dump, the files, InfluxDB's backup as a tar of what
influx backup writes, or the cache's RDB file.
It works on any destination, and you need no key and no credentials of ours.
The download comes from the console's own address, for whoever may export the
environment and is signed in. From the command line, vallic backup download
prints a direct link that works for five minutes; run it again for another.
The copy itself is deleted two days after it was made. Prepare it again for a
fresh one.
The database dump does not name a database, so it imports into any you point
it at. Use ddev import-db --file=… on a laptop, or vallic db import into
another environment. A dump downloaded from a backup taken before 29 October
2026 starts with CREATE DATABASE and USE lines. Remove those two before
importing it elsewhere.
When a subscription ends
The machines are destroyed a day after the end of the period you paid for. The backups are kept for thirty days after the subscription ends, so the site can be brought back. Then they are deleted from our storage: the data itself, not only the record of it.
A copy in your own storage stays where it is, with its key still yours.
Copying data between environments
Nothing that was there before survives: a copy replaces, it does not merge.
Use Backups → Copy from another environment to get realistic data into staging. It is not read from a backup: what arrives is what the source holds right now. The database is rebuilt and the file directories are mirrored.
A deploy follows, and it is not optional: the update hooks and configuration import have to run on the database that arrives.
Nothing is scrubbed unless you say so. See Sanitising what arrives.
Not available into production.
Where the database has a machine of its own, the copy runs in parts, shown as separate rows under Activity:
- The database, on the database machine.
- The files, on the web machine.
- Your sanitisation commands, where the application runs.
A restore of the database there does the same: the data goes back on the database machine, then your sanitisation and the cache rebuild follow on the web machine.
Resetting a database
Backups → Reset database empties the environment's database and starts it
again on the version vallic.yaml declares. A backup is taken first and the
newest backup is restored after.
It exists for one job: moving to a database version that cannot read the old files. Start at Service upgrade.
Only an Admin or the Owner can do it, only the Owner on production, and only by typing the environment's name.
Sanitising what arrives
We do not scrub anything on our own. You declare what to scrub in
.vallic/commands/sanitization.yml:
commands:
- 'drush sql:sanitize --yes'
- 'drush sql:query "UPDATE orders SET customer_email = CONCAT(id, ''@example.test'')"'
- 'drush sql:query "TRUNCATE payment_tokens"'
The commands run in your application container, in order. They run immediately after the database arrives, from a copy or from a restore into that environment, and before anyone can reach it. The first one to fail stops the rest and fails the task.
If the file is not there, nothing runs. Production data lands in staging exactly as it was, and every developer with access to that environment can read it.
The file is read from the environment receiving the data, on the branch it is running.
Never on production. On a restore into production the file is not read and nothing runs, whatever it declares.
Next
- Logs — the other thing that leaves the machine
- Shell access — importing a database dump by hand
Thank you. Good to know it helped.
Thanks — tell us what was missing. Open a ticket from Support in the console, and we answer on the ticket. Open the console