Once Forgejo looked usable, the next serious question was not deployment.

It was restore.

That is usually the more honest test of whether a self-hosted service is operational.

The Backup Model I Wanted

I wanted the backup system to follow the same general rules I use elsewhere:

  • encryption handled centrally,
  • uploads handled centrally,
  • application-specific commands run in the right local user context,
  • and database plus filesystem coverage treated as one backup concern rather than two unrelated scripts.

That makes the backup path easier to audit and easier to scale across multiple stacks.

What Needs To Be Backed Up

For a Git service, the answer is never just "the repositories."

You also have to think about:

  • database state,
  • application data,
  • configuration,
  • and the infrastructure files that define how the service is actually started.

That is the difference between "I can recover commits" and "I can recover the service."

Why I Prefer A Streamed Model

A streamed backup path has a nice property:

  • gather the data,
  • package it,
  • encrypt it,
  • checksum it,
  • ship it out.

It keeps the backup flow explicit and reduces the temptation to leave large intermediate artifacts lying around on disk.

The security benefit is obvious, but the operational benefit matters too:

the path is easier to reason about when it is one deliberate pipeline.

Restore Matters More Than Backup Syntax

The important thing about backup design is not whether the script looks elegant.

It is whether I can answer basic recovery questions without improvising:

  • where does the database come from,
  • where do the files go back,
  • what order matters,
  • and which credentials or keys are required to complete the restore.

If that part is vague, the backup is only half real.

Why This Phase Was Important

Forgejo became much more real to me once I stopped thinking only about startup and started thinking in terms of:

  • loss,
  • rebuild,
  • and controlled recovery.

That is the point where a service stops being a nice host-side project and starts becoming infrastructure.