The missing step
What it actually takes to self-host
Every comparison on this site ends with a recommendation and stops there. These guides carry on: the RAM a tool really needs against what its docs claim, what a month costs on commodity hardware, how long setup takes, what you will be maintaining, and the one thing that catches people out.
169 guides so far, weighted to infrastructure and model tooling — the layers where the bills are large enough for the question to matter.
The six that catch almost everybody
defaults, not limitsNone of these are capacity limits you grow into. They are shipped defaults that quietly do the wrong thing until something breaks, which is why they catch experienced people too.
PostgreSQL
The default configuration is deliberately tiny — shared_buffers ships at 128 MB regardless of how much RAM the machine has, so Postgres will happily ignore 90% of your…
needs 4 GB for a real application database (docs say 256 MB)$24–48/mo for a 4–8 GB instance, against managed Postgres at 2–3× that for equivalent specs
Grafana Loki
Loki indexes labels, not log content — that is the design that makes it cheap.
needs 4 GB (docs say 1 GB)$20–40/mo plus object storage, against Splunk pricing that is famously per-GB-ingested
Ollama
CPU-only inference works and is roughly ten times too slow to use.
needs 8 GB VRAM for a 7B model at usable speed; 24 GB for 30B-class (docs say 8 GB system RAM)$0 on hardware you own. $150–400/mo for a rented 24 GB GPU, against per-token API billing that is cheaper below roughly 2M tokens a month.
faster-whisper
Whisper hallucinates on silence — long pauses, music or dead air produce confident invented sentences, often repeated phrases from training data.
needs 5 GB VRAM for large-v3 in float16; 2 GB with int8 (docs say 2 GB)$0 on hardware you own. A one-off archive transcription is a few dollars of rented GPU against a four-figure API invoice.
DuckDB
It is single-writer by design.
needs Roughly the size of the working set you query at once (docs say 512 MB)$0 — it is an embedded library, not a server. It runs inside your process.
Nextcloud
The default install uses SQLite, which falls over somewhere around three concurrent users and is painful to migrate off later.
needs 4 GB (docs say 512 MB)$12–24/mo for a 5-user instance on a 4 GB VPS, plus object storage if the library outgrows the disk
Layer 3 — Infrastructure
63 guidesSelf-hosting Nextcloud
Replaces Dropbox
needs 4 GB (docs say 512 MB)
Self-hosting Syncthing
Replaces Dropbox
needs 512 MB (docs say 128 MB)
Self-hosting Grafana + Prometheus
Replaces Datadog
needs 8 GB (docs say 2 GB)
Self-hosting Gitea
Replaces GitHub
needs 2 GB (docs say 512 MB)
Self-hosting Vaultwarden
Replaces 1Password
needs 512 MB (docs say 128 MB)
Self-hosting Immich
Replaces Google Photos
needs 8 GB (docs say 4 GB)
Self-hosting ClickHouse
Replaces Snowflake
needs 16 GB (docs say 4 GB)
Self-hosting Supabase
Replaces Firebase
needs 8 GB (docs say 4 GB)
Self-hosting MinIO
Replaces Amazon S3
needs 4 GB (docs say 2 GB)
Self-hosting authentik
Replaces Auth0
needs 4 GB (docs say 2 GB)
Self-hosting Woodpecker CI
Replaces GitHub Actions
needs 2 GB server + whatever the builds need on the agents (docs say 512 MB server)
Self-hosting GlitchTip
Replaces Sentry
needs 2 GB (docs say 1 GB)
Self-hosting Plausible
Replaces Google Analytics
needs 4 GB (docs say 2 GB)
Self-hosting Coolify
Replaces Heroku
needs 4 GB on the control node, plus whatever your apps need (docs say 2 GB)
Self-hosting Uptime Kuma
Replaces Pingdom
needs 1 GB (docs say 256 MB)
Self-hosting Docmost
Replaces Confluence
needs 2 GB (docs say 1 GB)
Self-hosting Infisical
Replaces HashiCorp Vault
needs 2 GB (docs say 1 GB)
Self-hosting Meilisearch
Replaces Algolia
needs 4 GB — it wants the index resident in memory (docs say 1 GB)
Self-hosting listmonk
Replaces Mailchimp
needs 1 GB (docs say 256 MB)
Self-hosting PostgreSQL
Replaces MongoDB Atlas
needs 4 GB for a real application database (docs say 256 MB)
Self-hosting Valkey
Replaces Redis
needs Your working set + 30% (docs say 128 MB)
Self-hosting Keycloak
Replaces Auth0
needs 4 GB (docs say 512 MB)
Self-hosting k3s
Replaces Red Hat OpenShift
needs 2 GB server + 1 GB per agent (docs say 512 MB server)
Self-hosting SigNoz
Replaces Datadog
needs 8 GB (docs say 4 GB)
Self-hosting Grafana Loki
Replaces Splunk
needs 4 GB (docs say 1 GB)
Self-hosting DragonflyDB
Replaces Redis
needs Working set + 20% — it is meaningfully more memory-efficient than Redis (docs say 1 GB)
Self-hosting Podman + Podman Desktop
Replaces Docker Desktop
needs 8 GB on the host (docs say 2 GB)
Self-hosting Jenkins
Replaces GitHub Actions
needs 4 GB controller, plus agents (docs say 512 MB)
Self-hosting Apache Airflow
Replaces Astronomer (Astro)
needs 8 GB (docs say 4 GB)
Self-hosting DuckDB
Replaces Snowflake
needs Roughly the size of the working set you query at once (docs say 512 MB)
Self-hosting Trino
Replaces Snowflake
needs 16 GB coordinator + 16 GB per worker (docs say 8 GB)
Self-hosting PocketBase
Replaces Firebase
needs 512 MB (docs say 64 MB)
Self-hosting Appwrite
Replaces Firebase
needs 6 GB (docs say 2 GB)
Self-hosting GrowthBook
Replaces LaunchDarkly
needs 4 GB (docs say 2 GB)
Self-hosting Unleash
Replaces LaunchDarkly
needs 2 GB (docs say 512 MB)
Self-hosting Seafile
Replaces Dropbox
needs 4 GB (docs say 1 GB)
Self-hosting ZITADEL
Replaces Auth0
needs 4 GB (docs say 1 GB)
Self-hosting Prefect
Replaces Astronomer (Astro)
needs 4 GB server (docs say 1 GB)
Self-hosting Netdata
Replaces Datadog
needs 1 GB per monitored node (docs say 200 MB)
Self-hosting OpenSearch
Replaces Splunk
needs 8 GB heap on a 16 GB machine (docs say 2 GB)
Self-hosting Typesense
Replaces Algolia
needs The index must fit in RAM — roughly 2× raw document size (docs say 512 MB)
Self-hosting Talos Linux
Replaces Red Hat OpenShift
needs 4 GB per node (docs say 2 GB)
Self-hosting Dokku
Replaces Heroku
needs 2 GB plus whatever your apps need (docs say 1 GB)
Self-hosting CapRover
Replaces Heroku
needs 2 GB control node plus app memory (docs say 1 GB)
Self-hosting OPNsense
Replaces Locked-Down Consumer Routers
needs 4 GB, or 8 GB if you run intrusion detection (docs say 2 GB)
Self-hosting OpenWrt
Replaces Locked-Down Consumer Routers
needs 256 MB for a comfortable install with extras (docs say 64 MB)
Self-hosting SeaweedFS
Replaces Amazon S3
needs 4 GB across master and volume servers (docs say 1 GB)
Self-hosting SurrealDB
Replaces MongoDB Atlas
needs 4 GB (docs say 512 MB)
Self-hosting Apache CouchDB
Replaces MongoDB Atlas
needs 4 GB (docs say 512 MB)
Self-hosting Memcached
Replaces Redis
needs Exactly the cache size you allocate (docs say 64 MB)
Self-hosting Dagster
Replaces Astronomer (Astro)
needs 8 GB (docs say 2 GB)
Self-hosting Flagsmith
Replaces LaunchDarkly
needs 4 GB (docs say 1 GB)
Self-hosting LocalAI
Replaces OpenAI API (ChatGPT)
needs 8 GB RAM for CPU inference; 8 GB VRAM for anything comfortable (docs say 4 GB)
Self-hosting BentoML
Replaces Modal
needs 4 GB plus model memory (docs say 2 GB)
Self-hosting SGLang
Replaces Replicate
needs 24 GB VRAM for useful production serving (docs say 16 GB system)
Self-hosting Colima
Replaces Docker Desktop
needs 4 GB allocated to the VM, on a 16 GB machine (docs say 2 GB)
Self-hosting Lima
Replaces Docker Desktop
needs 4 GB per VM (docs say 2 GB)
Self-hosting Rancher Desktop
Replaces Docker Desktop
needs 8 GB allocated, on a 16 GB machine (docs say 4 GB)
Self-hosting OrbStack
Replaces Docker Desktop
needs 4 GB, and it releases memory back better than the alternatives (docs say 2 GB)
Self-hosting GL.iNet routers
Replaces Locked-Down Consumer Routers
needs 256 MB models age far better than 128 MB ones (docs say 128 MB on the device)
Self-hosting Zabbix
Replaces Datadog
needs 4 GB for a few hundred hosts, and the database wants more (docs say 2 GB)
Self-hosting Gatus
Replaces Pingdom
needs A small slice of a server you already run. The author's Helm example caps it at 32 Mi. Only add PostgreSQL's footprint if you pick Postgres storage over SQLite. (docs say Not stated by the vendor. It is a single Go binary. The author's own Helm chart suggests a 32 Mi memory limit in a commented-out example.)
Self-hosting HyperDX
Replaces Sentry
needs 8 GB. Four services share the box — ClickHouse, the HyperDX app, the OpenTelemetry collector and MongoDB — and ClickHouse's own sizing guide says total memory should not go below 8 GB. (docs say 4 GB with 2 cores — the README's stated minimum for testing)
Layer 4 — Models & tooling
26 guidesSelf-hosting Ollama
Replaces OpenAI API (ChatGPT)
needs 8 GB VRAM for a 7B model at usable speed; 24 GB for 30B-class (docs say 8 GB system RAM)
Self-hosting vLLM
Replaces OpenAI API (ChatGPT)
needs 24 GB VRAM minimum for useful production serving (docs say 16 GB system RAM)
Self-hosting Qdrant
Replaces Pinecone
needs Vectors × dimensions × 4 bytes, in RAM, plus overhead — 1M × 768d is roughly 3 GB (docs say 1 GB)
Self-hosting pgvector
Replaces Pinecone
needs 8 GB — the HNSW index wants to be resident (docs say Whatever Postgres already uses)
Self-hosting LlamaIndex
Replaces LangChain
needs 4 GB for the app; your vector store is the real cost (docs say 1 GB)
Self-hosting faster-whisper
Replaces Deepgram
needs 5 GB VRAM for large-v3 in float16; 2 GB with int8 (docs say 2 GB)
Self-hosting Langfuse
Replaces LangSmith
needs 4 GB (docs say 2 GB)
Self-hosting LiteLLM
Replaces Portkey
needs 2 GB (docs say 512 MB)
Self-hosting MLflow
Replaces Weights & Biases
needs 4 GB server (docs say 1 GB)
Self-hosting Docling
Replaces AWS Textract
needs 8 GB — the layout models are the memory cost (docs say 2 GB)
Self-hosting Promptfoo
Replaces Braintrust
needs 2 GB (docs say 512 MB)
Self-hosting Chroma
Replaces Pinecone
needs 4 GB (docs say 512 MB)
Self-hosting Haystack
Replaces LangChain
needs 4 GB (docs say 1 GB)
Self-hosting Unstructured
Replaces AWS Textract
needs 8 GB with the high-resolution strategy (docs say 2 GB)
Self-hosting NVIDIA NeMo Guardrails
Replaces Azure AI Content Safety
needs 4 GB, more if rails call a local model (docs say 1 GB)
Self-hosting Microsoft Presidio
Replaces Azure AI Content Safety
needs 4 GB with the spaCy NLP models loaded (docs say 1 GB)
Self-hosting Aim
Replaces Weights & Biases
needs 2 GB (docs say 512 MB)
Self-hosting RAGFlow
Replaces Vectara
needs 16 GB (docs say 4 GB)
Self-hosting ClearML
Replaces Weights & Biases
needs 8 GB (docs say 4 GB)
Self-hosting LM Studio
Replaces OpenAI API (ChatGPT)
needs 16 GB system RAM, and VRAM is what actually decides your model (docs say 8 GB)
Self-hosting Dify
Replaces OpenAI AgentKit
needs 8 GB. The default compose file starts 16 containers — api, api_websocket, worker, worker_beat, web, plugin_daemon, agent_backend, Weaviate, PostgreSQL, Redis, nginx, two SSRF proxies, two sandboxes and a one-shot init job — and Dify's own macOS instructions ask for a Docker VM with 8 GiB. More if a local model shares the box. (docs say 4 GiB (Dify's stated minimum: 2 CPU cores, 4 GiB RAM))
Self-hosting Mistral AI
Replaces OpenAI API (ChatGPT)
needs 24 GB of VRAM for Ministral 3 14B in FP8 (stated on its card). Mistral Small 3.2 (24B) needs ~55 GB in bf16, or fits a single RTX 4090 once quantised per the Small 3.1 card. Small 4 (119B MoE) and Large 3 (675B MoE) are multi-GPU models. (docs say 8 GB of VRAM — Mistral's card for Ministral 3 3B says it fits in 8 GB in FP8, and less if further quantised)
Self-hosting Nomic Embed
Replaces OpenAI Embeddings API
needs Around 1 GB of RAM or VRAM for one request at a time (estimate from the 274–547 MB weights; no figure is published). Batching long inputs raises it. (docs say Not stated by the project. The model is ~0.1B parameters — 547 MB of fp32 weights on Hugging Face, 274 MB as the F16 build in Ollama — and runs on CPU.)
Self-hosting BGE-M3
Replaces OpenAI Embeddings API
needs Roughly 3–4 GB of RAM on CPU, or 2–3 GB of VRAM with use_fp16=True, for one request at a time (estimate; no figure is published). Encoding at the full 8,192-token max_length in large batches needs far more, which is why the card tells you to lower max_length if you can. (docs say Not stated by the project. About 567M parameters: the pytorch_model.bin is 2.27 GB in fp32 and Ollama's build is 1.2 GB; it runs on CPU.)
Self-hosting Helicone
Replaces Portkey
needs 8 GB. The all-in-one container runs the web dashboard, the Jawn API and proxy, PostgreSQL, ClickHouse and MinIO together, and ClickHouse's own sizing guide says total memory should not go below 8 GB. (docs say Not stated in the docs. Helicone's own 2025 self-hosting write-up says a t2.medium EC2 instance (2 vCPU, 4 GB) handles about 90% of typical workloads, up to a million logs a day.)
Self-hosting Axolotl
Replaces OpenAI Fine-Tuning
needs 24 GB of VRAM for comfortable LoRA or QLoRA on 7–14B models. Full fine-tuning an 8B is listed at 48 GB on one GPU, and 70B QLoRA+FSDP as "Dual GPU @ 21GB VRAM". Plenty of system RAM too — the FAQ says exit code -9 means you ran out of system RAM, not VRAM. (docs say 11 GB of VRAM — Axolotl's Llama-3 examples list LoRA on an 8B model (8-bit base) as "Single GPU @ 11GB VRAM"; their Qwen3 14B QLoRA Colab runs on a 16 GB T4, at 9.26 GB after loading)
Layer 5 — Applications
80 guidesSelf-hosting LibreOffice
Replaces Microsoft 365
needs 2 GB with a large spreadsheet open (docs say 512 MB)
Self-hosting ONLYOFFICE
Replaces Microsoft 365
needs 6 GB for the Document Server with a handful of concurrent editors (docs say 2 GB)
Self-hosting Collabora Online
Replaces Microsoft 365
needs 4 GB, and roughly 1 GB per 20 concurrent documents (docs say 2 GB)
Self-hosting CryptPad
Replaces Google Drive
needs 2 GB for a small instance (docs say 1 GB)
Self-hosting Mattermost
Replaces Slack
needs 4 GB for a team of 50 with PostgreSQL on the same box (docs say 2 GB)
Self-hosting Rocket.Chat
Replaces Slack
needs 6 GB with MongoDB on the same machine (docs say 2 GB)
Self-hosting Zulip
Replaces Slack
needs 4 GB for a small organisation (docs say 2 GB)
Self-hosting n8n
Replaces Zapier
needs 2 GB, and 4 GB once workflows run concurrently (docs say 512 MB)
Self-hosting Node-RED
Replaces Zapier
needs 1 GB for a real flow set (docs say 256 MB)
Self-hosting Activepieces
Replaces Zapier
needs 2 GB (docs say 1 GB)
Self-hosting Huginn
Replaces Zapier
needs 2 GB with a busy agent set (docs say 1 GB)
Self-hosting Bruno
Replaces Postman
needs 600 MB as an Electron app (docs say 256 MB)
Self-hosting Hoppscotch
Replaces Postman
needs 2 GB for the self-hosted stack (docs say 512 MB)
Self-hosting Insomnia
Replaces Postman
needs 700 MB as an Electron app (docs say 256 MB)
Self-hosting PhotoPrism
Replaces Google Photos
needs 4 GB, and 8 GB if you index a large library (docs say 2 GB)
Self-hosting LibrePhotos
Replaces Google Photos
needs 6 GB, and it will use more during face recognition (docs say 2 GB)
Self-hosting Ente Photos
Replaces Google Photos
needs 2 GB for the server components (docs say 1 GB)
Self-hosting Bitwarden
Replaces 1Password
needs 4 GB for the official self-hosted stack (docs say 2 GB)
Self-hosting KeePassXC
Replaces 1Password
needs 300 MB (docs say 128 MB)
Self-hosting Matomo
Replaces Google Analytics
needs 4 GB once traffic is real, and MySQL wants most of it (docs say 1 GB)
Self-hosting Umami
Replaces Google Analytics
needs 1 GB with PostgreSQL alongside (docs say 256 MB)
Self-hosting Home Assistant
Replaces Proprietary Smart-Home Hubs
needs 4 GB once you add add-ons and a database (docs say 2 GB)
Self-hosting openHAB
Replaces Proprietary Smart-Home Hubs
needs 2 GB — the JVM is the floor (docs say 1 GB)
Self-hosting Logseq
Replaces Notion
needs 2 GB with a large graph open (docs say 512 MB)
Self-hosting AppFlowy
Replaces Notion
needs 1 GB for the desktop app; 2 GB for the self-hosted cloud (docs say 512 MB)
Self-hosting Anytype
Replaces Notion
needs 1.5 GB (docs say 512 MB)
Self-hosting GIMP
Replaces Adobe Photoshop
needs 4 GB for large multi-layer images (docs say 1 GB)
Self-hosting Krita
Replaces Adobe Photoshop
needs 8 GB for large canvases at print resolution (docs say 2 GB)
Self-hosting Jitsi Meet
Replaces Zoom
needs 8 GB for the videobridge under real load (docs say 4 GB)
Self-hosting BigBlueButton
Replaces Zoom
needs 16 GB — this is the documented production minimum, not a suggestion (docs say 8 GB)
Self-hosting OpenProject
Replaces Jira
needs 4 GB. The vendor sizes its minimum for up to 200 users, so a 5–20 person team fits inside it (docs say 4 GB)
Self-hosting Mautic
Replaces Mailchimp
needs 4 GB for a list in the low tens of thousands, 8 GB beyond that. One 4 GB server ran out of memory updating segments at about 50,000 contacts on Mautic 5. (docs say not stated by the vendor. Its official Docker image gives each PHP process a 512 MB memory limit, Cloudron packages it with a 1 GB limit, and Mautic says not to use shared hosting.)
Self-hosting Ory Kratos
Replaces Auth0
needs 1–2 GB for Kratos, PostgreSQL and a login UI together. Kratos itself is a single Go binary and keeps no state of its own. (docs say not stated by the vendor. Ory's own single-server production example runs Kratos, PostgreSQL, Nginx and the Node.js login UI on a 1 GB VM with 25 GB of SSD.)
Self-hosting Zammad
Replaces Freshdesk
needs 16 GB for a single-server install. The vendor's floor is 6 GB for Zammad plus 4 GB for Elasticsearch, and the usual VPS size above that is 16 GB. You can fit it on 8 GB by capping the Elasticsearch heap, which Zammad itself calls a less-than-ideal fix. (docs say 6 GB, plus 4 GB more if Elasticsearch runs on the same server. The Docker Compose guide asks for at least 4 GB just to start the containers.)
Self-hosting Chatwoot
Replaces Freshdesk
needs 4 GB plus 1 GB of swap is enough for a small team. Sidekiq alone can use more than 1 GB on a busy server, and 8 GB is the vendor's figure for 20,000 conversations a day. (docs say 4 GB (the vendor minimum, sized for up to 10,000 conversations a day), plus at least 1 GB of swap so upgrades do not run out of memory)
Self-hosting FreeScout
Replaces Freshdesk
needs 1–2 GB. The vendor says the cheapest VPS works; 2 GB gives MySQL and the queue worker room as mailboxes and history grow. (docs say not stated by the vendor. Its wiki says there are no minimum requirements and that the cheapest $5/mo server, including an EC2 t2.nano with 512 MB, is enough. Cloudron runs it under its default 256 MB app limit, with MySQL as a separate service.)
Self-hosting UVdesk
Replaces Freshdesk
needs 4 GB. That is the vendor's own floor, and there is no lighter documented setup. (docs say 4 GB (vendor README and system-requirements page))
Self-hosting EspoCRM
Replaces Salesforce
needs 2–4 GB. The official Docker stack runs four containers (app, daemon, websocket, MariaDB). A 4–5 user Docker install reported 40% of 4 GB in use, and forum users put 2 GB as fine for light use. (docs say not stated by the vendor. A forum super-moderator says 1 GB is enough for a plain Nginx + PHP-FPM + MariaDB install, and Cloudron packages it with a 512 MB app limit, with MySQL as a separate service.)
Self-hosting SuiteCRM
Replaces Salesforce
needs 4 GB. Even a test box is quoted at 3 GB, and production adds MySQL, the cron and, from 8.10, a Messenger worker. (docs say not stated by the vendor. Community guidance puts a test or development machine at 3 GB of RAM and about 10 GB of disk, with PHP's memory_limit at 256 MB or more.)
Self-hosting Excalidraw
Replaces Miro
needs Negligible on the server: all the drawing happens in each visitor's browser (docs say Not stated by the vendor. The official image is nginx (stable-alpine-slim) serving static files, which is about as small as a web app gets)
Self-hosting Hubitat Elevation
Replaces Proprietary Smart-Home Hubs
needs Nothing to provision; the hub is the whole system. You only need a browser on your phone or laptop to reach the hub's local web interface (docs say Not applicable. It's a sealed hub you buy, not software you install, and Hubitat gives no memory figure beyond 'expanded memory' on the C-8 Pro listing)
Self-hosting Jami
Replaces Zoom
needs Nothing server-side for one-to-one calls. The real requirement moves to whoever starts a group call: that device receives every participant's video, mixes it and sends the mixed stream back to each person, so its upload carries one outgoing stream per participant (docs say Not stated by the vendor, because there is no server to size: Jami runs on each person's device. The optional pieces (an OpenDHT node from Savoir-faire Linux's Alpine container, a standard coturn TURN server) publish no RAM figure either)
Self-hosting Nextcloud Talk
Replaces Zoom
needs 4 GB for Nextcloud plus the Talk backend container on one box (docs say 128 MB per PHP process (512 MB recommended), which is Nextcloud's own minimum; Talk runs inside it. The high-performance backend (signaling server, Janus, NATS, TURN) publishes no RAM figure)
Self-hosting Element Call
Replaces Zoom
needs 2–4 GB for Synapse, PostgreSQL, the LiveKit SFU and the MatrixRTC authorization service on one small box (docs say Not stated by the vendor. Element Call itself is a set of static files; Synapse, the homeserver it depends on, asks for at least 1 GB of free RAM if you join large public rooms, and LiveKit publishes no RAM figure)
Self-hosting API Dash
Replaces Postman
needs Whatever your machine already has: it is an ordinary desktop app. The heavy part is building a current version from source, which needs the Flutter SDK and the platform toolchain (on Windows, full Visual Studio with the C++ desktop workload). (docs say Not stated by the vendor. It is a native Flutter desktop app, and there is no documented footprint.)
Self-hosting Pinta
Replaces Adobe Photoshop
needs Depends on your images. Every layer is a full uncompressed canvas at 4 bytes per pixel, so a 24-megapixel photo costs about 96 MB per layer, before undo history (docs say Not stated by the vendor. Pinta 3.1 needs .NET 8 or later, GTK 4.18+ and libadwaita 1.7+; on Linux the Flatpak and Snap packages bring those with them)
Self-hosting Baserow
Replaces Airtable
needs 4 GB. Baserow staff advise starting at 4 GB, and say a basic setup grows to about 3 GB (docs say 2 GB for the all-in-one baserow/baserow image, as stated in Baserow's own forum FAQ)
Self-hosting Grist
Replaces Airtable
needs 8 GB. That is Grist's 'known good configuration for a variety of moderate workloads'. Memory follows how many documents are open at once, because each open document is loaded fully into RAM (docs say Not stated by the vendor. Its docs show one template document served from a container with 100 MB RAM (200 MB with sandboxing) and 1 CPU)
Self-hosting Teable
Replaces Airtable
needs 4 GB. That is the vendor's stated minimum for the app, PostgreSQL and Redis together, and Teable publishes no higher recommended figure. Treat it as the floor and watch memory once tables grow large (docs say 4 GB)
Self-hosting NocoDB
Replaces Airtable
needs 8 GB. That is the vendor's production specification, with 4 vCPU and 50 GB+ disk; its 2 GB minimum is for trying it out (docs say 2 GB (with 2 vCPU and 10 GB disk))
Self-hosting Forgejo
Replaces GitHub
needs 2 GB for Forgejo plus PostgreSQL on one box for a 5–20 person team. CI builds need their own machine (docs say Not stated by the vendor. Cloudron's package runs it within the default 256 MB app-container limit and runs PostgreSQL and Redis separately)
Self-hosting GitLab Community Edition
Replaces GitHub
needs 16 GB, the vendor's single-node baseline. 8 GB can carry 5–20 people if you disable the bundled Prometheus and trim Sidekiq and Puma as the memory-constrained guide describes (docs say 8 GB for a memory-constrained single node; 16 GB is the stated baseline. A separate tuning guide runs it on 2 GB plus 1 GB swap for up to 5 developers, with degraded performance)
Self-hosting Gogs
Replaces GitHub
needs 1 GB for Gogs plus a database. The README says memory use stays low as teams grow (docs say 512 MB with 2 CPU cores, the README's 'baseline for teamwork'. It says a Raspberry Pi or $5 droplet is 'more than enough to get you started')
Self-hosting Plane
Replaces Jira
needs 8 GB, the vendor's recommendation for production (docs say 4 GB)
Self-hosting Redmine
Replaces Jira
needs 2 GB for Redmine plus PostgreSQL or MySQL on one box. Each app process sits at 256–512 MB and can spike past 1 GB on large issue trees or expensive queries (docs say Not stated by the vendor. A single Redmine app process normally uses 256–512 MB (redmine.org issue #34497). Cloudron's package caps the app container at 600 MB and runs the database separately)
Self-hosting Taiga
Replaces Jira
needs 2–4 GB. A community member running it on a 4 GB AWS t3.medium measured about 1.5 GB in use across all containers (September 2025) (docs say 1 GB (the production guide says 'at least 1GB RAM'))
Self-hosting Keila
Replaces Mailchimp
needs 1–2 GB for Keila and PostgreSQL together. This is an estimate from the 512 MB app limit Cloudron uses plus a small database; Keila publishes no sizing of its own. (docs say not stated by the vendor. Cloudron packages Keila with a 512 MB memory limit for the app, with PostgreSQL as a separate shared service.)
Self-hosting phpList
Replaces Mailchimp
needs 1–2 GB on a VPS for phpList with MySQL. A long-time phpList forum helper called a 2 GB VPS fine for slower sending, with more RAM needed as the database grows. (docs say not stated by the vendor. phpList is built to run on ordinary shared web hosting; its manual is written around a hosting provider's hourly sending caps.)
Self-hosting Wekan
Replaces Trello
needs 4 GB total, the README's production minimum (docs say 1 GB free for WeKan itself. The README says a production server should have at least 4 GB in total)
Self-hosting Kanboard
Replaces Trello
needs 1 GB for Kanboard plus PostgreSQL on one box. It is a PHP app, and no source I found says a small team needs more (docs say Not stated by the vendor. Cloudron's package runs the app container within its default 256 MB limit and runs the database separately)
Self-hosting Vikunja
Replaces Trello
needs 1 GB for Vikunja plus PostgreSQL on one box. The docs say you probably won't need Redis until you have more than a handful of users (docs say Not stated by the vendor. Cloudron's package runs it within the default 256 MB app-container limit and runs PostgreSQL separately)
Self-hosting Easy!Appointments
Replaces Calendly
needs 1 GB on a VPS covers PHP and MySQL for one business's booking traffic (docs say Not stated by the vendor. The install guide is written for ordinary PHP hosting (Apache 2.4+, PHP 8.2+, MySQL 5.7+, files uploaded by FTP), so a basic shared-hosting plan is the smallest documented footprint)
Self-hosting Cal.diy
Replaces Calendly
needs 2 GB to run the built image with PostgreSQL and Redis; 8 GB on whichever machine does the build (docs say Not stated by the vendor (the docs say it 'runs with pretty minimal hardware requirements by itself'). Building it is another matter: the project's Dockerfile gives Node a 6,144 MB heap for the build)
Self-hosting Rallly
Replaces Calendly
needs 2 GB covers the bundled stack (Traefik, PostgreSQL, Garage object storage and the app) for a team's polls (docs say 2 GB, as stated in the self-hosting prerequisites)
Self-hosting Appointments for Nextcloud
Replaces Calendly
needs Whatever your Nextcloud already uses, since the app adds no services. A Nextcloud stood up just for booking still means running all of Nextcloud; 4 GB is comfortable (docs say Nothing of its own, because it's a Nextcloud app. Nextcloud's minimum is 128 MB RAM per PHP process, with 512 MB per process recommended)
Self-hosting Kokoro
Replaces ElevenLabs
needs Well under 2 GB of VRAM on a GPU — Kokoro-FastAPI measured 758 MiB freed on unload after a short clip and 1,656 MiB after 7.5 minutes of long-form audio on an RTX 4060 Ti. On CPU, an ordinary laptop with a couple of GB free is enough (estimate; not stated at source). (docs say Not stated by the project. The weights are 327 MB (kokoro-v1_0.pth) and the community ONNX export is 92 MB at 8-bit; it runs on CPU.)
Self-hosting Chatterbox
Replaces ElevenLabs
needs About 5–6 GB of VRAM for the original 500M model — one user reports ~5 GB normally and 6 GB at peak on a GTX 1060 6 GB (GitHub issue #508). The project states no VRAM figure; Turbo (350M) is described as needing less. (docs say Not stated by the project. The smallest variant, Chatterbox-Nano (110M, English only), runs on CPU — Resemble says 3x faster than realtime on 8 cores.)
Self-hosting Aider
Replaces Cursor
needs With an API key: any laptop. Locally, to be usable: enough GPU or unified memory for a ~20 GB model plus its context (qwen2.5-coder:32b at 4-bit). In practice that means a 24 GB GPU or a 32 GB+ Apple Silicon Mac. The fp16 build named in aider's own config example is 66 GB. (docs say Not stated by the vendor. Aider is a Python CLI and needs almost nothing when it calls a hosted API. Run the model locally and the model sets the floor: Qwen2.5-Coder, the family in aider's Ollama docs, is a 4.7 GB download at 7B and 20 GB at 32B (4-bit) in the Ollama library.)
Self-hosting Cline
Replaces Cursor
needs 32 GB for a local model that actually works. Cline's tested minimum is Qwen3 Coder 30B at 4-bit (~17 GB download, 32K context, Compact Prompt on). 64 GB runs the 8-bit version (~32 GB) with 128K context and every feature. With an API key, any machine that runs VS Code is enough. (docs say Not stated for the extension itself, which runs inside VS Code or JetBrains. For local models, Cline's docs start at 16–32 GB of RAM for small or quantized models.)
Self-hosting PostHog
Replaces Amplitude
needs 16 GB, and that number is not padded. ClickHouse, Kafka, Zookeeper, PostgreSQL, Redis/Valkey, Temporal with Elasticsearch, a headless Chromium and a few dozen PostHog services all share it (about 38 services in the hobby compose file). (docs say 16 GB. PostHog's stated floor is the equivalent of a Hetzner VM with 4 vCPU, 16 GB RAM and more than 30 GB of storage.)
Self-hosting Metabase
Replaces Tableau
needs 2 GB for Metabase, which Metabase says is 'more than enough' for solo users or small teams, plus 2 GB for its PostgreSQL application database (docs say 1 GB (with 1 core), Metabase's stated baseline)
Self-hosting Apache Superset
Replaces Tableau
needs 8 GB with 2 vCPU, the community figure the Superset FAQ cites. The FAQ says needs grow with concurrent users and their activity, not with data size (docs say Not stated by the vendor. The only figure in its docs is the FAQ's community report that 8 GB RAM and 2 vCPU run a moderately-sized instance)
Self-hosting Directus
Replaces Contentful
needs 2 GB for the Directus container, the vendor's recommended minimum, plus room for PostgreSQL and Redis. That fits on a 4 GB VPS (docs say 512 MB (with 0.25 vCPU) for the Directus container. The database is extra)
Self-hosting BookStack
Replaces Confluence
needs 2 GB with MySQL on the same box for a team. A report on BookStack's GitHub describes normal speed on a 2 GB, 1 vCPU x86 VM. (docs say 1 GB. The vendor says it "can easily be ran on a 1GB RAM VM".)
Self-hosting Penpot
Replaces Figma
needs 4–8 GB for a small design team, with backend, frontend, exporter (a headless browser), PostgreSQL 15 and Valkey on one box. For the top end, the docs say 4 CPUs and 16 GB are enough for thousands of users. (docs say 4 GiB. Penpot's Community Advocate gives 1–2 CPUs and 4 GiB in the forum FAQ; the official docs state no minimum.)
Self-hosting Stirling PDF
Replaces Adobe Acrobat Pro
needs 4 GB for light use, 8 GB if people OCR scans or convert Office files. The docs say a 50 MB PDF can grow to 200–500 MB in memory, and LibreOffice and Tesseract run outside the Java heap, so set the container limit to at least 1.5× -Xmx. (docs say 4 GB, the vendor's smallest sizing tier (1–10 users: 2 cores, 4 GB, 10 GB disk, 4G container limit). There is an ultra-lite image for smaller machines, with core features only.)
Self-hosting Documenso
Replaces DocuSign
needs 2 GB or more (the vendor's production recommendation: 2+ cores, 2+ GB, 20+ GB), with PostgreSQL on the same box (docs say 1 GB (the vendor's minimum for testing: 1 core, 1 GB RAM, 10 GB storage))
Self-hosting Appsmith
Replaces Retool
needs 8 GB with 2 vCPU. That is Appsmith's own baseline for standard deployments, which it describes as an entry point for pilots and low traffic rather than a production guarantee (docs say 8 GB. The Docker docs say to plan for at least 8 GB on the host for the all-in-one container)
Self-hosting Budibase
Replaces Retool
needs 6 GB with 2 cores, the vendor's figure. The current compose file also runs a LiteLLM proxy with its own PostgreSQL, which comes out of the same budget (docs say Not stated by the vendor. Its Docker docs say 2 cores and 6 GB 'should be enough' for most use cases, and that is the only figure it gives)
Self-hosting Joplin
Replaces Evernote
needs 1–2 GB for Joplin Server plus PostgreSQL for a household or small group. The desktop and mobile apps run on your own devices. (docs say Not stated by the vendor. On the forum in 2022, Joplin Server 2.7 on a 1 GB Raspberry Pi 3 was killed for running out of memory while syncing about 200 MB of attachments (node reached ~1.3 GB of virtual memory).)
Common questions
- Why do these numbers differ from the official documentation?
- Because documented minimums are the figure at which a process starts, not the figure at which it works. Nextcloud documents 512 MB and is unusable below about 4 GB with a real library. That gap is the entire point of these pages — it is the number that decides whether self-hosting is a good idea for you, and it is the one nobody publishes.
- How are the monthly costs calculated?
- Commodity VPS pricing at roughly $6 per GB of RAM, sized to the practical requirement rather than the documented one, plus storage where storage dominates. They exclude your time, which is the larger cost for most people — so every guide states the ongoing maintenance burden separately and honestly.
- Do you only recommend self-hosting?
- No, and every guide here carries a 'when not to self-host' section for that reason. For plenty of teams the managed product is the correct answer — a password manager that is down when you need a credential is worse than paying for one. A site that only ever tells you to self-host is selling something.