---
title: "Deploy SilverBullet — Self-Hosted Markdown Knowledge Base [Updated Sep'26]"
description: "Self-host SilverBullet — Markdown notes & queryable second brain"
category: "Other"
url: https://railway.com/deploy/silverbullet-markdown-notes
---

# Deploy SilverBullet — Self-Hosted Markdown Knowledge Base [Updated Sep'26]

Self-host SilverBullet — Markdown notes & queryable second brain

**[Deploy SilverBullet — Self-Hosted Markdown Knowledge Base [Updated Sep'26] on Railway](https://railway.com/template/silverbullet-markdown-notes)**

Machine-readable deploy manifest (JSON, validated by TemplateCI): https://railway.com/deploy/silverbullet-markdown-notes/manifest.json

- **Creator:** SB
- **Category:** Other

## Template content

### silverbullet https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/png/silverbullet.png

- **Image:** ghcr.io/silverbulletmd/silverbullet
- **Public domain:** Yes

## Documentation

# Deploy and Host SilverBullet on Railway

SilverBullet is an open-source, Markdown-based note-taking app and personal knowledge base — a self-hosted "second brain" where every page is a plain `.md` file you fully own. It combines a live-preview editor, wiki-style links, and an indexed object database that lets you query your notes like a database, extended with embedded Lua scripting for custom workflows. Because notes are just Markdown on a volume, there's no proprietary format, no lock-in, and no per-seat pricing. This template deploys SilverBullet with a persistent volume for your notes and single-user auth — a private, portable knowledge base in minutes.

---

## What This Template Deploys

| Service | Purpose |
| --- | --- |
| **SilverBullet** | The Markdown editor, wiki, object index, and Lua engine on port `3000` |

A single lightweight service — no external database. SilverBullet stores every page as a plain Markdown file on a persistent volume mounted at `/space` and builds its queryable index from those files itself. Railway provides automatic HTTPS, which SilverBullet needs to function.

---

## About Hosting

SilverBullet is refreshingly simple, and two specifics make it work correctly and keep your notes safe — both handled here.

**Every page is a Markdown file on the `/space` volume — persist it.** SilverBullet's whole philosophy is that your notes outlive the tool: each page is a plain `.md` file under `/space`, with no database to lock them in. This template mounts a persistent volume there, so your entire knowledge base survives redeploys — and upgrades are just an image-tag bump that never touches your data. Miss the volume and your notes vanish on redeploy; mount it, and they're portable, greppable text you can back up anywhere.

**HTTPS is required — and Railway provides it automatically.** This is the key technical point: SilverBullet relies on the browser's service worker (for offline sync) and clipboard APIs, which browsers only enable over a secure connection — over plain HTTP, the app doesn't work properly. Railway serves your instance over automatic HTTPS out of the box, so sync and the full editor work immediately — a genuine platform advantage over a bare VPS.

**Single-user auth via `SB_USER`.** SilverBullet uses simple basic authentication for one user: `SB_USER` in the form `username:password` sets your login. This template generates strong credentials, which you'll find in the Variables tab and can change by updating `SB_USER` and redeploying. Note it's single-user by design — one shared credential, ideal for a personal knowledge base or a small team sharing one login, rather than multi-account access.

**Your Markdown is a database, and it's a PWA.** SilverBullet parses every page into objects — tasks, tags, headers, links, front matter — and holds them in an index the editor queries live, so a directory of text files behaves like a queryable database, with embedded Lua for custom queries and automations. It's also a progressive web app, so once deployed you use it from any browser and install it on your phone with offline support — a personal wiki, daily journal, project planner, or second brain.

Typical cost: **~$5/month** on Railway for the single lightweight service and volume. SilverBullet is MIT-licensed and free, versus per-seat or subscription note apps.

---

## How It Compares

| | SilverBullet (self-hosted) | Notion | Obsidian | Google Keep |
| --- | --- | --- | --- | --- |
| Storage format | Plain Markdown files | Proprietary cloud | Local Markdown | Proprietary cloud |
| Access | Any browser + PWA | Apps | Desktop-first | Apps |
| Query your notes | Yes (object index + Lua) | Databases | Plugins | No |
| Cost model | Flat infra | Per seat | Free + paid sync | Free |
| Data ownership | Full — your infra | Vendor | Local files | Google |
| Self-hostable | Yes | No | Sync is paid | No |

Notion is powerful but stores your notes in a proprietary cloud with per-seat pricing. Obsidian is a great local editor, but browser access and sync across devices are paid add-ons. Google Keep is convenient but closed and basic. SilverBullet's edge is a browser-based, self-hosted knowledge base in plain Markdown — queryable and scriptable, accessible from anywhere — where your notes are portable text files on infrastructure you own, with no per-seat cost.

---

## Deploy in Under 5 Minutes

1. Click **Deploy on Railway** — SilverBullet builds with a `/space` volume for your notes (~2 minutes)
2. Confirm the volume is mounted at `/space` and note the generated `SB_USER` credentials
3. Open your Railway URL (served over HTTPS) and log in
4. Type a new page name in the top bar to create your first page, and start writing in Markdown
5. Install it as a PWA on your phone for note-taking anywhere

Change `SB_USER` to your own `username:password` and redeploy to set custom credentials.

---

## Common Use Cases

- **Personal knowledge base** — a private, self-hosted second brain in portable Markdown
- **Daily journal** — a fast, distraction-free place to write, owned entirely by you
- **Queryable notes** — treat your Markdown as a database with embedded Lua scripts
- **Portable note-taking** — plain `.md` files you can back up, grep, or migrate anytime

---

## Configuration

| Variable | Required | Description |
| --- | --- | --- |
| `SB_USER` | Required | Single-user login as `username:password` — set a strong value |
| `SB_AUTH_TOKEN` | Optional | Bearer token for API and sync backends |
| `SB_INDEX_PAGE` | Optional | The default page to load (defaults to `index`) |
| Storage volume | Pre-set | Persistent volume at `/space` — every note as a Markdown file |
| `PORT` | Pre-set | `3000` — the SilverBullet server |

> **Persist `/space` — it holds every note.** SilverBullet stores each page as a Markdown file there with no external database, so the volume is your entire knowledge base — mounted here so notes survive redeploys, and upgrades never touch your data.

> **HTTPS is required (Railway provides it), and auth is single-user.** SilverBullet's service worker and clipboard APIs need HTTPS, which Railway handles automatically. `SB_USER` sets one `username:password` login — change it and redeploy for custom credentials.

---

## Dependencies for SilverBullet Hosting

- Railway account — ~$5/month for the lightweight service and volume
- A persistent volume at `/space` for your Markdown notes (included)
- Nothing else — no external database, and HTTPS is provided by Railway
- A modern browser, or install the PWA on mobile

### Deployment Dependencies

- [SilverBullet GitHub Repository](https://github.com/silverbulletmd/silverbullet)
- [SilverBullet Documentation](https://silverbullet.md/)
- [SilverBullet Configuration Reference](https://silverbullet.md/Install/Configuration)
- [Railway Volumes Documentation](https://docs.railway.com/volumes)

### Implementation Details

The template runs the official `ghcr.io/silverbulletmd/silverbullet` image on port `3000`, with a persistent volume mounted at `/space` that holds every note as a plain Markdown file. There is no external database: SilverBullet parses the Markdown files into an object index (pages, tasks, tags, headers, links, front matter) that the client queries live, so the directory of text files behaves like a queryable database while remaining portable, greppable Markdown. Upgrades are performed by bumping the image tag and redeploying, which never touches the data directory.

A key requirement is HTTPS: SilverBullet's client relies on the browser service worker (for offline sync) and clipboard APIs, which browsers restrict to secure contexts, so the app malfunctions over plain HTTP. Railway's automatic HTTPS on the generated domain satisfies this without additional configuration. Authentication is single-user via `SB_USER` (a `username:password` pair); `SB_AUTH_TOKEN` can enable bearer-token auth on the HTTP API for sync or remote storage backends.

SilverBullet is a progressive web app installable on mobile, with embedded Lua scripting for custom queries and automation. The `/space` volume is the single backup target, and because it's plain Markdown, backups and migrations are straightforward.

---

## Frequently Asked Questions

**Where are my notes stored?** As plain Markdown files on the `/space` volume — one `.md` file per page, with no external database. This template mounts the volume so your notes persist across redeploys, and because they're plain text you can back them up, grep them, or migrate them anywhere.

**Why does SilverBullet need HTTPS?** Its offline sync (service worker) and clipboard features rely on browser APIs that only work over a secure connection, so it malfunctions on plain HTTP. Railway serves your instance over automatic HTTPS, so everything works out of the box.

**How does login work?** SilverBullet uses single-user basic auth via `SB_USER` (`username:password`). This template generates credentials you'll find in the Variables tab; change them by updating `SB_USER` and redeploying. It's one login by design, ideal for personal or shared-single-login use.

**Is my data locked in?** No — every note is a plain Markdown file, so there's no proprietary format. Your knowledge base is portable text you fully own and can move anywhere, which is the point of self-hosting SilverBullet.

---

## Why Deploy SilverBullet on Railway?

Railway is a singular platform to deploy your infrastructure stack. Railway will host your infrastructure so you don't have to deal with configuration, while allowing you to vertically and horizontally scale it.

By deploying SilverBullet on Railway you get a Markdown knowledge base with the essentials handled — a persistent volume for your notes, automatic HTTPS so sync and the editor work, and single-user auth configured. A portable, queryable second brain in plain Markdown, self-hosted on infrastructure you own.

## Similar templates

- [Rocky Linux](https://railway.com/deploy/rocky-linux) — Hosted Rocky Linux 9 workspace with SSH and persistent storage. 🚀
- [Foundry Virtual Tabletop](https://railway.com/deploy/X5tR6G) — A Self-Hosted & Modern Roleplaying Platform
- [Letta Code Remote](https://railway.com/deploy/letta-code-remote) — Run a Letta Code agent 24/7. No inbound ports, just deploy.

Open this page in a browser: https://railway.com/deploy/silverbullet-markdown-notes