Where the data comes from
Alternatives are sourced from the public GitHub REST API v3 — specifically
GET /search/repositories
and
GET /repos/{owner}/{repo}.
For each candidate repository we record: repository name, owner, description, primary language, SPDX
license id, star count, archived flag, and the pushed_at timestamp of the latest commit on
the default branch. A nightly cron-driven ETL re-fetches this data and the site is
rebuilt automatically, so what you see on a comparison page reflects what GitHub returned at the last
nightly build, not a stale manual snapshot. The clickable repository link on every alternative card is
the primary citation — it points at the GitHub source that supplied each value on that card.
Each alternative card surfaces the last-pushed date for the underlying repository so you can judge maintenance freshness directly from the source signal rather than trusting a generic "updated" banner. We deliberately do not paper over silence: if upstream has not shipped a commit in 12+ months we say so on the page rather than reusing the SaaS comparison's own "last reviewed" date.
Data we do not use: download counts from package registries (npm/PyPI/Docker Hub) are excluded because they are gameable and inconsistent across ecosystems; we rely on stars + last-pushed as the cross-language baseline.
What AI writes vs. what we write by hand
We are explicit about this so readers can tell repository facts apart from editorial framing, and see which sentences were drafted with a language model and which were written by hand. The split is:
- AI-generated (Claude Sonnet 4.6 and Claude Haiku 4.5 via the Anthropic API or Claude Code): the per-page intro paragraph, the pros/cons framing, the "who should use this / who should skip" decision cues, and the FAQ phrasing. Models are prompted against the upstream GitHub metadata for that specific SaaS + its top alternatives — they do not invent repositories.
- Deterministic / templated: the alternative cards themselves (name, stars, license, language, last-pushed) are rendered straight from GitHub API data, untouched by any model. Sort order, the "X of N shipped a commit in the last 12 months" line, and the curation gate (see below) are pure code.
- Human-edited: this page, the About page, the legal pages, the per-alternative "honest tradeoff" takes, and any correction applied after a reader report. The per-SaaS intros are AI-drafted against the upstream metadata and reviewed editorially before a page clears the curation gate that decides what gets indexed.
For fields that move between rebuilds — licensing nuance (AGPL vs. GPL vs. SSPL implications), version numbers, pricing, and recent project status (forks, archive events, governance changes) — the upstream repository linked on every comparison page is the authoritative citation. We link it directly on each card so the current state is always one click away from the editorial summary.
How we rank these projects
We sort by GitHub star count, but we treat stars as a community-size signal, not a quality signal — a 50,000★ project with no commits in 18 months is not what you want to deploy in production. Each project on a comparison page is annotated with its last-pushed date, language, and license so you can apply your own ranking weights. Our threshold for calling a project "actively maintained" is at least one commit in the past 12 months; the per-page "X of N shipped a commit in the last 12 months" line above each comparison is calculated against that bar.
How we score each project
The "At a glance" table on each comparison page turns raw GitHub data into three decision axes, so you can scan the trade-offs before reading the long write-ups. Each value comes from applying a fixed editorial rubric to public signals — the rubric and its thresholds are our editorial judgement, but we apply them consistently rather than scoring projects by gut feel, and we never invent benchmarks we haven't measured.
- Adoption — a plain bucket of the GitHub star count: Niche (<1k), Established (1k–4,999), Mainstream (5k–29,999), Flagship (30k+). It proxies how much community knowledge, plugins and deployment runbooks you'll find, not code quality.
- Maintenance — based on the last push date: Active (within 90 days), Maintained (within a year), Stale (older). A stale repo isn't automatically wrong, but it changes your support calculus before you self-host.
- Commercial-use risk — read from the SPDX license id, not the star count: permissive (MIT/Apache/BSD) is Low, weak copyleft (LGPL/MPL) is Medium, strong/network copyleft (GPL/AGPL/SSPL) and source-available (BUSL/Elastic) are High, and anything without a clear SPDX id is Unknown — treat it as all-rights-reserved until you read the LICENSE file yourself.
What the table deliberately does not show is anything we'd have to fabricate — startup time, Docker readiness or migration effort require actually running each project, so we only publish those when we've tested them and say so explicitly. The axes above are decision aids; the GitHub repo linked on each row is always the primary source.
Below the scores, each project also shows raw upstream activity pulled straight from the GitHub API — its latest release and date, how many releases shipped in the last year, the open issue/PR count, and an archived-repository warning where it applies. Those are unedited facts, refreshed automatically. We deliberately don't attach an opinion to them: the editorial judgement belongs in the written take, not in an auto-generated caption.
Why some SaaS pages aren't published
Not every SaaS we have data for makes the cut. A comparison page is built, indexed, and linked internally only when it clears all of these objective gates:
- At least 3 open-source alternatives with usable metadata (so a comparison table is actually possible)
- The top alternative has at least 800★ on GitHub (no anonymous / empty-topic pages)
- The intro paragraph is at least 80 characters of real generated text (no templated stubs)
- The intro was produced by a real editorial model, not a hard-coded fallback template
Category pages follow the same logic at the category level: a category page is only built when it
contains at least 1 curated SaaS page.
Sub-threshold SaaS are not given a public comparison page at all — a page is only generated once it
clears the gate, so thin entries never reach the index, sitemap, internal navigation, RSS feed, or
breadcrumbs rather than being published as a low-value page. The rationale: we'd rather have fewer
pages that are each worth reading than a wide index of thin pages, both for readers and for
search-quality compliance. The exact thresholds live in src/lib/curation.ts and are
mirrored in astro.config.mjs so the sitemap cannot drift from the in-page logic.
Self-hosting cost reality check
For most workloads, a single $5–10/month VPS (1 vCPU, 1–2 GB RAM) runs the OSS project itself. The real cost is operational: backup automation, OS patching, TLS renewal, monitoring, and incident response. Budget 2–8 engineering hours per month per service in steady state, and a one-time 20–40 hour setup window covering deployment, runbook authoring, and the first failover drill. Below ~$200/month in SaaS spend, the math rarely favours self-hosting; above ~$1,000/month it almost always does, especially once you factor in data residency and vendor lock-in hedging.
These ranges are not pulled from a vendor white paper — they are what we have repeatedly seen on
our own infrastructure running this site's adjacent services. We self-host the analytics
sink, the ETL scheduler, and the article queue that feeds this directory; the numbers above reflect
time we have actually spent on TLS renewals, log rotation that pinned a disk, and the migration
where a forgotten postgres minor-version bump silently broke our nightly backup until a
manual restore drill caught it. The reason we publish ranges and not single numbers is that the
variance between "runs a Docker Compose once a quarter" and "PII-bearing production" is roughly an
order of magnitude.
A realistic migration timeline
Most teams budget 4–8 weeks in calendar time when moving off a SaaS: about 1 week of evaluation pilot, 2–3 weeks of data export and import scripting, 1–2 weeks of parallel run with both systems live, and 1–2 weeks of user cutover. Always export the SaaS data into a portable format (CSV, JSON, or the spec format the OSS tool accepts) before you touch production. The per-page "Migration tips" section, when present, covers the data-shape gotchas specific to that SaaS.
When you should stay on the SaaS
Self-hosting pays back at scale and political-risk hedging, not at small-team convenience. Stay on the SaaS if any of these apply: (a) your team is under 5 people and the SaaS bill is under $200/month — ops cost will exceed savings; (b) you depend on a SaaS-exclusive integration that no OSS project replicates; (c) you don't have a single engineer with 4+ hours/week to own the self-hosted stack.
Editorial independence
We are not affiliated with the vendors, projects, or models listed beyond standard, disclosed affiliate programs for adjacent services (e.g. VPS hosting referral links). A vendor paying an affiliate commission does not buy placement, a higher ranking, or a more favorable summary. See our Affiliate Disclosure for the full picture, and our Privacy Policy for how visitor data is handled.
Found a mistake? Tell us.
AI summaries get licensing edge cases wrong. Star counts go stale between rebuilds. Projects get
archived, forked, or relicensed without us noticing. If you see something incorrect — especially on
licensing, archive status, or governance — send the page URL and what is wrong to the address on the
Contact page (prefix the subject with [correction]). We
acknowledge within 5 business days and aim to ship the fix within 14 days. Maintainers of indexed
projects can also request removal from the same address; see the Contact page for the verification
steps.
When this changes
If we materially change how data is sourced, how rankings are computed, which models we use, or how affiliate links are placed, we update this page and the "Last updated" date on the relevant legal page. The framework above is intentionally stable — the per-page numbers move with the underlying GitHub data, not with our opinions.