Why we run Forgejo

Last updated: 31 January 2026
Scope: This document explains why Lighthouse operates its own Git service using Forgejo and what that decision does and does not mean.

1. The context

Modern software development depends on Git hosting. For most teams, that effectively means choosing one of a small number of very large platforms.

Those platforms are convenient, well resourced, and familiar. They also operate within specific legal jurisdictions, evolve quickly, and increasingly blend code hosting with analytics, automation, and AI-assisted features.

For many people, the default choice is sensible and practical. For Lighthouse, it was worth pausing and asking a few extra questions.

2. The questions we needed clear answers to

We were not trying to make a statement, and we were not looking to escape anything.

We were trying to answer some basic, reasonable questions:

• Where does our source code actually live?
• Who can access it, and under what legal framework?
• What processing happens to it beyond storage and delivery?
• How easy is it to leave if our needs change?

As platforms consolidate and broaden their feature sets, the answers to those questions become harder to pin down. In particular:

• Data access policies are often intentionally broad.
• AI-assisted features may involve additional processing of repository content.
• Legal reach can extend beyond where servers are physically hosted.
• Migration is possible, but rarely frictionless.

Legal jurisdiction is treated as a first-class design consideration, not an abstract legal footnote.

None of this is inherently bad. It is, however, relevant.

3. The trade-offs we accepted

Running our own Git service is not the easy option.

It brings real responsibilities with it:

• System administration
• Updates and patching
• Backups and recovery
• Uptime and monitoring

At the same time, it removes a different set of concerns:

• Platform lock-in
• Uncertainty about data handling
• Dependency on changing terms and product direction
• Silent coupling to services we did not explicitly choose

In short, we traded convenience for clarity. We prefer tooling where secondary use of repository content is explicit and opt-in, not implicit or assumed.

That trade only makes sense if you are willing to operate infrastructure properly. We are.

4. Why Forgejo

Forgejo is a community-governed, open-source Git service, developed with an emphasis on transparency, sustainability, and boring reliability.

We chose Forgejo because:

• It is fully open source, with visible governance
• It is not driven by venture capital growth targets
• It supports standard Git workflows without proprietary lock-ins
• It runs cleanly on modest, well-understood infrastructure
• It lets us decide exactly how integrations and data flows work

Just as importantly, it does not try to be everything.

That restraint is part of its strength.

5. What this decision does not mean

Running Forgejo does not mean:

• We think large platforms are evil
• We expect everyone else to self-host
• We refuse to collaborate with people using other services
• We believe self-hosting removes all risk

It simply means that for our own work, and for projects trusted to us, we prefer arrangements where responsibility and accountability are clear and local.

6. What this means in practice

In practical terms, running our own Git service gives us:

• Clear control over where our code lives
• Predictable data handling
• Explicit choices about integrations and tooling
• Straightforward backup and recovery
• The ability to explain our setup plainly to clients, partners, and auditors

This clarity allows us to explain our stack to clients in concrete terms, rather than abstractions.

It also means that if our requirements change, we can move without asking permission.

That freedom is easy to underestimate until you need it.

7. Closing note

This document is not an argument, and it is not a recommendation.

It exists to explain a decision we have made, the thinking behind it, and the trade-offs involved.

For Lighthouse, running Forgejo is not about ideology.

It is about governance, clarity, and long-term maintainability.

Those are qualities we value in software, and in the systems that support it.