The Indie Hacker's Guide to Building on Open Source

As an indie hacker, your two scarcest resources are money and time. Open source gives you both back — if you use it strategically.

The Indie Hacker's OSS Stack

Your Product Stack (Build With)

Need	Tool	Why
Database	Supabase (self-hosted) or PocketBase	Auth + database + storage in one
Backend	PocketBase (Go binary) or Supabase	Zero infrastructure for MVP
Auth	Supabase Auth or Logto	Don't build auth yourself
Search	Meilisearch	Instant search, simple API
Email (transactional)	Resend or SES ($0.10/1K)	OSS tools send, SaaS delivers
Payments	Stripe	No OSS alternative that works
Hosting	Coolify on Hetzner	Deploy anything, $7/month

Your Business Stack (Run With)

Need	Tool	Replaces	Savings
Analytics	Plausible	Google Analytics	Privacy + accuracy
Email marketing	Listmonk	Mailchimp	$0 vs $20+/month
Customer support	Chatwoot	Intercom	$0 vs $39+/month
Scheduling	Cal.com	Calendly	$0 vs $12/month
Monitoring	Uptime Kuma	Better Stack	$0 vs $25/month
Link tracking	Dub	Bitly	$0 vs $35/month
Forms	Formbricks	Typeform	$0 vs $29/month
CRM	Twenty	HubSpot	$0 vs $20+/month
Automation	n8n	Zapier	$0 vs $49/month

Total SaaS cost replaced: $230+/month → $0 (software) + $7-14 (hosting)

The $14/Month Indie Stack

Everything you need to launch and run a product:

Component	Tool	Server
Product backend	PocketBase	Server 1
Product hosting	Coolify	Server 1
Analytics	Plausible	Server 2
Email marketing	Listmonk	Server 2
Customer support	Chatwoot	Server 2
Scheduling	Cal.com	Server 2
Monitoring	Uptime Kuma	Server 2
Link shortener	Dub	Server 2
Reverse proxy	Caddy	Both

Server 1: Hetzner CX22 ($4.50) — Your product Server 2: Hetzner CX32 ($7) — Your business tools SMTP: Amazon SES ($2.50) Total: $14/month

Building With OSS: Practical Patterns

Pattern 1: PocketBase MVP

Ship an MVP in a weekend:

// PocketBase gives you auth + database + API + file storage
const pb = new PocketBase('https://api.yourapp.com')

// Auth
await pb.collection('users').authWithPassword('user@email.com', 'pass')

// CRUD
const posts = await pb.collection('posts').getList(1, 20)
await pb.collection('posts').create({ title: 'Hello', body: '...' })

// Realtime
pb.collection('posts').subscribe('*', (e) => console.log(e))

No backend code needed. Frontend talks directly to PocketBase.

Pattern 2: Supabase Full-Stack

For more complex apps:

// Supabase: PostgreSQL + Auth + Storage + Realtime + Edge Functions
import { createClient } from '@supabase/supabase-js'
const supabase = createClient(url, key)

// Auth with magic link
await supabase.auth.signInWithOtp({ email: 'user@email.com' })

// Query with row-level security
const { data } = await supabase
  .from('posts')
  .select('*')
  .eq('user_id', user.id)

// File upload
await supabase.storage.from('avatars').upload('avatar.png', file)

// Realtime subscriptions
supabase.channel('posts').on('postgres_changes',
  { event: 'INSERT', schema: 'public', table: 'posts' },
  (payload) => console.log(payload)
).subscribe()

Pattern 3: Coolify Deploy Pipeline

# 1. Install Coolify on your VPS
curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash

# 2. Point your repo at Coolify
# Push to main → Coolify auto-deploys

# 3. Add services from Coolify marketplace
# PostgreSQL, Redis, Meilisearch — one click each

No Docker knowledge required. No CI/CD to configure. Push and deploy.

Monetization-Friendly OSS Stack

Revenue Model	OSS Tools to Support It
SaaS (subscriptions)	Supabase (user management) + Stripe + Plausible (track conversions)
Marketplace	Medusa (e-commerce) + Meilisearch (search) + Stripe
Content/courses	PocketBase (content delivery) + Listmonk (email marketing) + Plausible
Consulting	Cal.com (booking) + Twenty (CRM) + Chatwoot (communication)
Community	Mattermost (chat) + Outline (knowledge base) + Formbricks (feedback)

Automation Recipes for Indie Hackers

Using n8n to automate your indie business:

New Customer Onboarding

Stripe webhook (new subscription)
  → Create user in PocketBase
  → Send welcome email via Listmonk
  → Add to CRM (Twenty)
  → Notify you in Mattermost

Content Publishing

New blog post (webhook)
  → Create short link (Dub API)
  → Schedule social posts
  → Add to email newsletter (Listmonk)
  → Track in Plausible (custom event)

Support Triage

New Chatwoot message
  → Check if customer (PocketBase lookup)
  → If paying customer → priority label
  → If common question → auto-respond with link
  → If urgent → notify Mattermost channel

Common Mistakes

1. Over-Engineering the Stack

Mistake: Self-hosting 15 tools before you have customers. Fix: Start with PocketBase + Plausible + Listmonk. Add tools as needs emerge.

2. Building Instead of Shipping

Mistake: Spending 2 weeks perfecting your self-hosted setup. Fix: Use managed options (Supabase Cloud, Plausible Cloud) for MVP, self-host when revenue justifies it.

3. Ignoring Backups

Mistake: "I'll set up backups later." Fix: Set up automated daily backups on day 1. It takes 15 minutes.

4. Premature Self-Hosting Everything

Mistake: Self-hosting email (Mailu/Mail-in-a-Box) to save $6/month. Fix: Some things are worth paying for. Email deliverability is hard.

The Decision Framework

Stage	Approach	Budget
Idea validation	All free tiers (SaaS)	$0
MVP	PocketBase/Supabase + Coolify	$7-14/month
First customers	Add Plausible + Listmonk + Chatwoot	$14/month
$1K MRR	Full self-hosted stack	$14-30/month
$5K MRR	Upgrade servers, add redundancy	$50-100/month
$10K+ MRR	Consider managed options for sanity	$100-300/month

Integrating Your Stack: Making the Tools Talk

The real productivity gain comes when your tools work together. Isolated tools are useful; connected tools multiply your leverage. With n8n as the glue layer, you can automate workflows that would otherwise require hiring a virtual assistant.

Consider what happens when a new subscriber joins your mailing list in Listmonk. That event should ripple outward: create a contact in your Twenty CRM, tag them with the source campaign, trigger a sequence of welcome emails, and post a notification to your Mattermost channel so you know in real time. Without n8n, you'd either pay for Zapier ($49/month) or do this manually. With n8n running on your $7 VPS alongside everything else, it costs you nothing incremental.

The same logic applies to payment events. When Stripe fires a charge.succeeded webhook, n8n can update a row in your PocketBase database, send a receipt via Amazon SES, add the customer to a "paying users" segment in Listmonk, and start a drip campaign for onboarding. That entire customer lifecycle automation takes roughly two hours to build once, then runs forever without additional cost.

For content creators and SaaS founders who publish regularly, connecting Plausible's API to a weekly digest is straightforward. Every Monday, n8n queries your top pages, formats the results, and delivers a summary to your Mattermost channel. You stay informed about what's resonating without opening a dashboard. If you want deeper product analytics — funnel analysis, retention cohorts — PostHog is another strong open source option that self-hosts alongside your existing stack and plugs naturally into the same n8n workflows.

Authentication is another integration surface worth planning early. If you run multiple tools (Outline for documentation, Chatwoot for support, Mattermost for chat), each one having its own user database quickly becomes painful. Deploying Authentik or Logto as a centralized identity provider means users sign in once and access everything. When an employee leaves, you deactivate them in one place and they lose access everywhere. This single investment in SSO setup pays dividends every time your team changes. For a deep comparison of the leading open source identity platforms, see Keycloak vs Authentik 2026.

Security and Backup Practices Every Indie Hacker Needs

The biggest operational risk when self-hosting is not a server going down — it's data loss. Hardware fails, VPS providers have incidents, and misconfigured Docker volumes have swallowed entire databases. The right backup strategy takes less than an hour to set up and eliminates this risk entirely.

For PocketBase, the built-in backup API makes this trivial. Schedule a daily cron job that calls the backup endpoint and pipes the output to Backblaze B2 or an S3-compatible bucket. Backblaze charges $6 per terabyte per month, so your backup costs for an indie project are effectively zero. For PostgreSQL-backed tools (Supabase, Plausible, Outline), pg_dump piped to a compressed archive and uploaded via rclone achieves the same result. Test your restores quarterly — a backup you've never restored is not a backup.

On the security side, running a self-hosted stack exposes you to attack surface that managed SaaS handles silently. A few non-negotiable practices: deploy every service behind a reverse proxy (Caddy with automatic HTTPS is the easiest), never expose database ports to the public internet, use fail2ban to block brute-force SSH attempts, and rotate secrets annually. For anything involving user passwords or payment data, enable two-factor authentication on your VPS provider account and on every critical service.

Secrets management deserves its own consideration as your stack grows. Hardcoding credentials in .env files works for a single developer but breaks down when you add collaborators or switch servers. A lightweight approach is to store secrets in Infisical or use SOPS to encrypt your .env before committing it to your private git repository. For more on the options available, the best open source alternatives to HashiCorp Vault 2026 covers the tradeoffs between Infisical, OpenBao, and SOPS in detail — all of which fit comfortably in an indie hacker's budget.

Monitoring is the other half of operational safety. Uptime Kuma watching your public endpoints sends alerts before customers notice downtime. Pair it with Grafana and Loki for log aggregation if your project grows to the point where you need to debug production issues quickly. The time investment is around half a day, and the peace of mind is worth it once you have paying customers depending on your service.

The Long-Term Economics of Building on Open Source

The compounding advantage of an OSS-first stack becomes most visible at the 12-month mark. At that point, you've spent roughly $168 on hosting while a SaaS-dependent competitor has spent $2,760 or more on the same set of tools. That $2,592 difference represents pure runway — additional months you can operate without external funding, additional marketing budget, or simply additional profit.

The economics improve further as you grow. SaaS pricing is almost always per-seat, meaning your tool costs scale linearly with headcount. Self-hosted OSS doesn't work that way. Adding ten users to your Mattermost instance or your Outline wiki costs nothing. Adding one more project to Plane doesn't trigger an upgrade email. Your infrastructure costs grow much more slowly than your team does, which means your margins improve as you hire.

There are honest tradeoffs. Self-hosting requires you or someone on your team to handle updates, monitor for vulnerabilities, and occasionally troubleshoot Docker networking issues at 11pm. For complex tools like Keycloak or Supabase, the operational overhead is real. The framework for deciding whether to self-host or pay for managed SaaS is straightforward: calculate the total cost of ownership including your hourly rate for maintenance, then compare it against the SaaS price. If you're billing $100/hour and spending two hours per month on a tool that costs $30/month managed, self-hosting costs you more in time than it saves. For tools that require minimal maintenance — Plausible, Vaultwarden, Uptime Kuma — the calculation strongly favors self-hosting. You can find a detailed worked example of this calculation in the ROI framework for switching to open source.

The skills you build while running a self-hosted stack also have compounding value. Linux administration, Docker networking, PostgreSQL, reverse proxy configuration — these are foundational DevOps skills that make you a better engineer and reduce your dependency on expensive contractors. Many successful indie hackers describe their self-hosted stack as an ongoing education that has directly improved their products.

The Bottom Line

As an indie hacker, open source is your unfair advantage:

• $0 software costs means more runway
• Full control means no feature limitations
• Data ownership means you can pivot freely
• Self-hosting skills compound over your career

Start with 3-4 tools. Ship your product. Add more as you grow.

---

Find every tool you need for your indie stack at OSSAlt.