Raneto

A flat-file knowledge base for teams who want documentation to live next to their code, not inside a SaaS dashboard.

TL;DR

• What it is: A free, MIT-licensed knowledge base platform for Node.js that stores all content as plain Markdown files — no database, no cloud lock-in [2].
• Who it’s for: Small technical teams, solo developers, and non-technical founders who want internal documentation without standing up Postgres, managing user tables, or signing up for another SaaS subscription.
• Cost savings: Raneto is free software. A working instance runs on a $5–6/mo VPS. Compare that to Notion ($16/user/mo for teams), Confluence ($5.75+/user/mo), or GitBook ($6.70+/user/mo) where documentation costs scale with your headcount.
• Key strength: Zero database dependency. Content is just Markdown files in a folder — version it with Git, back it up with rsync, edit it in your IDE. The mental model is as simple as the tool [2].
• Key weakness: Limited ecosystem, modest GitHub traction (2,878 stars vs. 14,000+ for BookStack and 24,000+ for Wiki.js), and third-party review coverage is thin — a signal that the project hasn’t broken out of its niche [2]. The web config system is also listed as “Coming Soon” on the homepage, which suggests active development is uneven [1].

---

What is Raneto

Raneto is a Node.js knowledge base that stores everything as Markdown files in a directory. There is no database. When you add a file to content/pages/, it shows up in the knowledge base. When you delete it, it disappears. That’s the entire content model [2].

The project describes itself as “a free, open, simple Markdown-powered knowledge base” [2], and the simplicity part is accurate. The feature list is short by design: a browser-based Markdown editor, full-text search powered by Lunr.js, a login system to protect editing, Bootstrap-based theming with Mustache templates, and syntax highlighting via Highlight.js [1][2].

What it is not: a wiki with revision history, a collaboration platform with inline comments, or an enterprise document management system. It is a lightweight tool for teams that want documentation to live next to their code without pulling in a database or a SaaS account.

The project sits at 2,878 GitHub stars — a modest number that reflects the tool’s scope and age rather than any technical failing [2]. The official docs run on Raneto itself at docs.raneto.com, which is the most honest possible demo: the docs are the product in production [1].

---

Why people choose it

Third-party review coverage of Raneto is sparse — no major comparison articles, no Trustpilot presence, no G2 profile with enough reviews to synthesize. What does exist is a pattern from the broader flat-file documentation community:

The no-database argument. The recurring reason developers reach for Raneto over something like BookStack or Wiki.js is deployment simplicity. No Postgres to provision, no Redis to configure, no migration scripts to run. Content lives in the filesystem — it’s trivially backed up, trivially diffed in Git, and trivially moved between servers. For a team that already manages infrastructure and doesn’t want another stateful service to babysit, this is a real advantage [2].

Markdown-native workflows. Raneto’s content model aligns with how many developers already work. You can write docs in your editor, commit them with the code they document, and have Raneto serve them. The browser editor exists for non-technical contributors, but it’s optional — the underlying source stays as readable .md files [2].

License clarity. MIT license, no commercial use restrictions, no “fair-code” asterisks. You can embed it in a client delivery, deploy it behind an internal proxy, or modify it however you want [2].

---

Features

Based on the README and website [1][2]:

Content management:

• All content is plain Markdown files stored in a configurable directory (CONTENT_DIR)
• Pages are organized by folder structure, which becomes the navigation hierarchy
• Browser-based Markdown editor with ALLOW_EDITING=true — protected by login
• Pages can be created and edited without SSH access once the editor is enabled

Search:

• Full-text search powered by Lunr.js — runs client-side, indexes file names and content [1]
• No Elasticsearch, no external search service required

Authentication:

• Single admin credential via ADMIN_USERNAME / ADMIN_PASSWORD environment variables
• AUTHENTICATION=true enables the login gate — off by default [2]
• No multi-user management, no roles, no SSO. One credential per instance.

Presentation:

• Bootstrap-based theme, customizable
• Mustache templating for layout modifications
• Syntax highlighting via Highlight.js [1]
• Google Analytics 4 support via GOOGLE_ANALYTICS_ID [2]
• Locale support for multi-language UI (LOCALE env var) [2]

API:

• REST API is listed as a canonical feature in the project profile — scope and documentation are not detailed in available primary sources. Data not available on specific endpoints.

Deployment:

• npm-based install or Docker (raneto/raneto:0.18.1) [1][2]
• Configured entirely via environment variables or config/config.js
• Listens on 127.0.0.1:8080 by default — expects a reverse proxy in front for HTTPS [2]

What’s absent: revision history, page-level permissions, WYSIWYG editing, inline comments, user management beyond one login, database-backed search, or any kind of multi-tenancy. These are not missing features so much as deliberate scope decisions. If you need them, Raneto is the wrong tool.

---

Pricing: SaaS vs self-hosted math

Raneto has no SaaS offering and no paid tier. It is free software.

Self-hosted cost:

• Software: $0 (MIT) [2]
• VPS to run it: $5–6/mo (Hetzner CX11, Contabo S, or similar)
• Storage: negligible — Markdown files are tiny
• Reverse proxy: free (Caddy autocerts, or nginx if you have it already)
• Domain: $10–15/yr if you don’t have one

Total: ~$6/month ongoing, ~$10–15 one-time for a domain.

Commercial documentation SaaS for comparison:

Tool	Price	Model
Notion (Teams)	$16/user/mo	Per-seat
Confluence	$5.75/user/mo	Per-seat, climbs fast
GitBook	$6.70/user/mo	Per-seat
Coda	$10/user/mo	Per-seat
Notion (Plus solo)	$10/mo	Single user

For a 5-person team using Confluence, that’s $28.75/mo minimum. For Notion Teams, $80/mo. Raneto at $6/mo flat regardless of team size is a meaningful cost difference over a year, especially for a startup watching burn [data: pricing from respective vendor sites, not cited inline because these are published rates, not claims from a specific article].

The trade-off is real: those SaaS tools include hosting, backups, uptime guarantees, and support. Raneto gives you none of that. You own the infrastructure, which means you own the risk.

---

Deployment reality check

The install path is straightforward:

git clone https://github.com/ryanlelek/Raneto.git
cd Raneto
npm install
npm start

Or Docker Compose [2]:

services:
  raneto:
    image: raneto/raneto:0.18.1
    ports:
      - "8080:8080"
    volumes:
      - ./config:/opt/raneto/config
      - ./content:/opt/raneto/content
    environment:
      - NODE_ENV=production
    restart: unless-stopped

What you actually need:

• A Linux VPS with ~512MB RAM (Node.js + static files — the memory footprint is minimal)
• Node.js 18+ or Docker
• A reverse proxy for HTTPS (Caddy is the lowest-friction option)
• An SMTP provider only if you need email features — Raneto itself doesn’t send email

What can go sideways:

The homepage notes that the JavaScript-based configuration (config.js) is labeled “Coming Soon” [1]. This suggests the project’s configuration documentation is incomplete, which matters if you need to go beyond environment variables. The environment variable table in the README is clear and covers the main knobs, but anyone needing advanced customization may find the config surface underdocumented.

The single-credential authentication model is a real limitation for teams with more than one editor. There is no per-user access control, no audit trail of who edited what, and no way to grant read-only access to some users while allowing editing for others. If you need that, you’ll need to put a separate auth proxy (like Authelia) in front of Raneto.

Since content is stored as flat files, you’ll want to set up Git tracking on the content/ directory separately if you care about revision history. Raneto itself does not version files [2]. One deleted Markdown file is one permanently deleted page unless you have your own backup system.

Estimated time to a working HTTPS instance for a developer comfortable with Linux: 20–40 minutes. For a non-technical founder following a guide: 2–4 hours including domain setup. If you’ve never touched a terminal, hire someone for a one-time setup.

---

Pros and Cons

Pros

• Genuinely no database. The deployment footprint is as small as it gets for a functional knowledge base. There is nothing to corrupt, migrate, or restore except a directory of text files [2].
• MIT licensed with no commercial restrictions. Use it in client deliveries, internal tooling, or embedded products without calling a lawyer [2].
• Content is portable. Markdown files owned by you. Move to a different tool, serve them with Docusaurus, or read them raw — the lock-in is zero.
• Editable via browser or IDE. Non-technical contributors can use the built-in editor; developers can commit directly to the content directory [2].
• Low resource requirements. A $5 VPS handles this comfortably. No Postgres, no Redis, no message queue.
• Lunr.js search is fast for small corpora. Client-side search means no server-side search infrastructure, and for a knowledge base under a few hundred pages, latency is imperceptible [1].
• Docker image available. The Docker Compose path is three copy-paste commands from a working instance [2].

Cons

• Single credential authentication. No multi-user system, no roles, no SSO. One admin account per instance. Teams with more than one editor need a workaround [2].
• No revision history. Raneto does not version content. If a page gets overwritten or deleted, recovery depends entirely on your own backup setup [2].
• Modest ecosystem and community. 2,878 GitHub stars puts it well below BookStack (~14,000), Wiki.js (~24,000), and even older tools like DokuWiki. This means fewer community themes, fewer integrations, less StackOverflow coverage [2].
• Config documentation is incomplete. The website explicitly labels the JavaScript config as “Coming Soon” [1]. This is a yellow flag for production deployments that need fine-grained configuration.
• Bootstrap theme feels dated. The default UI is functional but visually circa 2016. Custom theming requires knowing Mustache and Bootstrap [1].
• Lunr.js search does not scale. Client-side full-text search works well for hundreds of pages. At thousands of pages the index download and search time become noticeable. No server-side search alternative is available out of the box.
• REST API details are opaque. The API is listed as a feature but the documentation available doesn’t detail what endpoints exist, what they accept, or what they return. Data not available.
• No built-in backup or sync. You handle content persistence entirely. No S3 sync, no automated export, no point-in-time restore.

---

Who should use this / who shouldn’t

Use Raneto if:

• You want documentation that lives next to your code in Git and deploys from a folder of Markdown files.
• You’re a solo founder or small team (fewer than 5 people) who needs internal documentation without SaaS pricing per seat.
• You value deployment simplicity over feature breadth — no database is a genuine benefit when your VPS already runs three other services.
• You’re comfortable managing a reverse proxy and a Node.js process, or willing to learn.
• Your content model is flat articles, not relational data with categories, tags, and complex relationships.

Skip it (pick BookStack instead) if:

• You need per-user permissions, page-level access control, or audit trails. BookStack has all three and runs on a comparably simple LAMP stack.
• Your team wants WYSIWYG editing, inline image uploads, and a visual page tree. BookStack’s editor is significantly richer.
• You want active community, frequent releases, and an ecosystem of themes and integrations.

Skip it (pick Wiki.js instead) if:

• You need Git-backed storage with a proper multi-user system, page history, and GraphQL API.
• You want a more modern, actively developed codebase — Wiki.js is under active development with a large user base.

Skip it (stay on Notion or Confluence) if:

• Multiple team members need to collaborate in real time, leave inline comments, or manage document permissions by page.
• You’re not comfortable managing your own server and don’t have someone to set it up for you.
• The $6/month savings doesn’t justify the setup and maintenance overhead for your team.

Skip it (pick MkDocs or Docusaurus) if:

• Your knowledge base is public-facing developer documentation and you want static site generation, CI/CD integration, and versioning by default. Those tools are built for that use case; Raneto is not.

---

Alternatives worth considering

• BookStack — PHP/MySQL, far more feature-complete (multi-user, roles, WYSIWYG, API), ~14,000 GitHub stars. The natural step up from Raneto for teams that outgrow single-editor constraints.
• Wiki.js — Node.js (same runtime as Raneto), Git-backed storage option, multi-user, GraphQL API, modern UI, ~24,000 stars. Significantly more complex to deploy but significantly more capable.
• DokuWiki — The old-school flat-file wiki. PHP, no database, enormous plugin ecosystem, battle-tested. If Raneto’s simplicity appeals to you but you want more features and a larger community, DokuWiki is worth a look.
• Outline — The modern Notion-style wiki. Requires Postgres and Redis, but the collaboration features are genuinely good. MIT licensed (recently changed from BSL), actively developed.
• Gollum — Git-backed wiki used internally by GitHub. File-based like Raneto but tightly integrated with Git history. Simpler even than Raneto in some ways, more powerful in others.
• MkDocs / Docusaurus — Static site generators for documentation. Better choice if you want public-facing docs with versioning, search, and CI/CD deployment. Not the right tool for internal knowledge management.

---

Bottom line

Raneto does exactly one thing: it serves a folder of Markdown files as a searchable knowledge base with a browser-based editor and a login gate. If that matches your documentation problem, it’s hard to beat — MIT licensed, no database, trivial to deploy, zero per-seat cost. The trade-offs are real: no revision history, no multi-user system, a modest community, and documentation gaps that show the project’s limited bandwidth. For a solo founder or small team that wants internal documentation to live as plain files on a $6/mo server, Raneto is a legitimate choice. For teams that need access control, audit logs, or an active ecosystem, the category has better options in BookStack and Wiki.js.

If deploying any of these tools is the bottleneck, upready.dev handles one-time self-hosted deployments — you get the tool, you own the server, and you’re done paying SaaS fees.

---

Sources

1. Raneto Official Website — https://raneto.com (raneto.com)
2. Raneto GitHub Repository (README and project metadata) — https://github.com/ryanlelek/raneto (github.com)
3. Raneto Docker Hub Image — https://hub.docker.com/r/raneto/raneto (hub.docker.com)
4. Raneto Live Demo and Documentation — https://docs.raneto.com (docs.raneto.com)

Note: No usable third-party review articles for Raneto were available at research time. The review above is based entirely on primary sources: the official website, GitHub README, and Docker Hub. The absence of community reviews is itself a signal about the project’s adoption footprint and is noted in the analysis.