🗄️ Recipedia — Database Integration Report

Current Architecture

Recipedia is a static HTML/CSS/JS site deployed on Netlify (free tier). Data is currently stored as:

• Recipes → hardcoded in recipes.js (~21 KB)
• Product inventory → localStorage (per-browser, ~5 MB limit)
• Ingredient translations → hardcoded in ingredients-dictionary.js

Current Limitations

Netlify Free Tier Context

Any solution must work within Netlify’s free plan:

[!IMPORTANT] Netlify deploys static sites. Server-side databases (MySQL, PostgreSQL on your own server) require a separate backend or a serverless/BaaS approach.

Option Comparison Matrix

Detailed Analysis

1. 🟢 IndexedDB (Client-Side Upgrade)

What: Built-in browser database — a powerful upgrade over localStorage without any external services.

Free tier: Unlimited (it’s a browser API).

Strengths: - Zero cost, zero setup, zero external dependencies - Works offline by default - Supports structured data (objects, not just strings) - Much larger storage than localStorage (GB vs 5 MB) - No API keys or accounts needed - Keeps the app fully static — perfect for Netlify

Weaknesses: - Data stays on one device/browser — no cross-device sync - No admin panel — recipes still managed in code - More complex API than localStorage (consider using Dexie.js wrapper) - Users lose data if they clear browser storage

Integration effort: 🟢 Low — replace localStorage calls with IndexedDB via Dexie.js

[!TIP] Best if you want a quick improvement without adding any backend complexity. Ideal as a stepping stone — migrate products to IndexedDB now, add a cloud database later.

2. 🔵 Netlify DB (Powered by Neon PostgreSQL)

What: Netlify’s native serverless PostgreSQL database, powered by Neon. One-click setup from the Netlify dashboard.

Free tier limits:

Strengths: - Native Netlify integration — one-click provisioning, auto-connects to Netlify Functions - Full PostgreSQL — relations, joins, constraints, full SQL power - Serverless with auto-scaling and auto-suspend when idle - No cold starts on free tier - Great for structured data (recipes, categories, users) - Can use ORMs like Prisma or Drizzle

Weaknesses: - Requires Netlify Functions as middleware (client → function → DB) - 512 MB storage limit on free tier - No built-in auth (need to add separately) - No realtime subscriptions - No offline support - Slightly more complex architecture

Integration effort: 🟡 Medium — need to create Netlify Functions as API endpoints

Client (JS) → Netlify Function (API) → Neon PostgreSQL

[!TIP] Best if you want to stay 100% within the Netlify ecosystem and need proper relational data modeling.

3. 🟠 Firebase Firestore

What: Google’s NoSQL cloud database with real-time sync, offline support, and built-in authentication.

Free tier limits (Spark Plan):

Strengths: - Offline support built-in — cached data works without internet - Realtime listeners — instant UI updates when data changes - Firebase Auth — Google, email, anonymous auth out of the box - Direct client-side access (no backend needed) - Generous free tier for a recipe app - Excellent documentation and community - Easy to add push notifications, analytics, hosting

Weaknesses: - NoSQL data model — no joins, denormalization required - Complex queries are limited (no full-text search, no OR queries across fields) - Vendor lock-in (Google ecosystem) - Pricing can spike unexpectedly if reads/writes grow - Feb 2026: Cloud Storage requires Blaze plan (pay-as-you-go) even for free usage - Document-oriented structure may feel unnatural for relational recipe data

Integration effort: 🟡 Medium — add Firebase SDK, refactor data access layer

Client (JS) → Firebase SDK → Firestore (direct)

[!TIP] Best if you want offline support + realtime sync + auth in one package. Ideal for a recipe app where users might browse recipes without internet.

4. 🟣 Supabase

What: Open-source Firebase alternative built on PostgreSQL. Offers database, auth, storage, realtime, and edge functions.

Free tier limits:

Strengths: - Full PostgreSQL — SQL joins, constraints, views, functions - Built-in auth (email, OAuth, magic links) - Realtime subscriptions over WebSocket - Row-Level Security (RLS) for fine-grained access control - Auto-generated REST and GraphQL APIs - Open-source — no vendor lock-in, can self-host - Direct client-side access via supabase-js SDK - Dashboard with SQL editor and table viewer

Weaknesses: - Auto-pause after 7 days of inactivity on free tier ⚠️ - 500 MB storage limit - No built-in offline support - 2 project limit on free tier - Can be complex to set up RLS properly - Community-only support on free tier

Integration effort: 🟡 Medium — add Supabase SDK, create tables, set up RLS

Client (JS) → Supabase SDK → PostgreSQL (direct via API)

[!WARNING] The 7-day inactivity auto-pause is a dealbreaker for production apps. Your database will go offline if no one visits for a week, causing downtime until manually restored.

[!TIP] Best if you want full SQL power + auth + realtime without vendor lock-in. Consider the Pro plan ($25/month) if this becomes a production app.

5. 🟤 Turso (Edge SQLite)

What: Distributed SQLite database at the edge, built on libSQL. Data is stored close to users for low latency.

Free tier limits (as of March 2025):

Strengths: - SQLite-compatible — familiar, simple SQL - Edge-hosted — extremely low latency - Generous free tier (5 GB, 500M reads) - No cold starts - Lightweight and fast - Embedded database model (libSQL) — can also run locally - Good Netlify integration via plugin

Weaknesses: - Requires Netlify Functions as middleware - No built-in auth - No realtime subscriptions - No offline client-side caching - Relatively newer service — smaller community - Edge replication removed from free tier

Integration effort: 🟡 Medium — set up Turso CLI, create DB, use via Netlify Functions

[!TIP] Best if you want the simplicity of SQLite with cloud distribution and great performance. The 5 GB free storage is the most generous among SQL options.

6. ⚫ MongoDB Atlas

What: Managed MongoDB cloud database with a free tier (M0 Shared cluster).

Free tier limits:

Strengths: - Flexible document model — perfect for varied recipe structures - Schema-less — different recipes can have different fields - Full-text search via Atlas Search - Change Streams for realtime updates - Large ecosystem and community - Aggregation pipeline for complex queries

Weaknesses: - Requires a backend — cannot safely expose connection strings to the client - No built-in auth (need separate service) - NoSQL — no joins, requires denormalization or $lookup - M0 free tier has limited performance - No offline support - Vendor lock-in concerns

Integration effort: 🔴 Higher — need Netlify Functions + MongoDB driver + connection management

Client (JS) → Netlify Function → MongoDB Atlas

🏆 Recommendation Matrix

🎯 Recommended Strategy for Recipedia

Phase 1: Quick Win (No Backend)

Upgrade localStorage to IndexedDB using Dexie.js: - Products get structured storage (~GB capacity) - Recipes stay in recipes.js (still works offline) - Zero cost, zero external dependencies

Phase 2: Cloud Database (When Ready)

Choose one based on priorities:

Phase 3: Full Features (Future)

• Add user accounts (auth)
  
• Admin panel for recipe management
  
• User-submitted recipes
  
• Favourites and meal planning sync

Architecture Diagrams

Current Architecture

graph LR
    A[Browser] -->|Static Files| B[Netlify CDN]
    A -->|Products| C[localStorage]
    B -->|recipes.js| A

With Cloud Database

graph LR
    A[Browser] -->|API Calls| B[Netlify Functions]
    B -->|SQL/NoSQL| C[Cloud Database]
    A -->|Static Files| D[Netlify CDN]
    A -->|Cache| E[IndexedDB]
    C -->|Recipes, Products| B

With Firebase (Direct)

graph LR
    A[Browser] -->|Firebase SDK| B[Firestore]
    A -->|Static Files| C[Netlify CDN]
    A -->|Offline Cache| D[IndexedDB auto]
    B -->|Realtime Sync| A

🖥️ Part 2: Lightweight Server-Side Databases & Hosting Platforms

This section focuses on self-hosted lightweight backends — solutions where you run your own small server with an embedded or lightweight database, and the platforms where you can host them for free or cheaply.

[!NOTE] Unlike Part 1’s BaaS options (Firebase, Supabase), these give you full control over the backend and data. The trade-off is more responsibility for hosting and maintenance.

Lightweight Backend Frameworks

These are all-in-one solutions that bundle a database + API + auth + admin panel in a lightweight package.

1. 🏆 PocketBase

What: A single Go binary (~15 MB) that includes SQLite, REST API, realtime subscriptions, auth, file storage, and an admin dashboard. Drop it on a server and you have a full backend.

Strengths: - Absurdly simple — download one file, run it, done - Zero dependencies — no Node.js, no Docker, no runtime needed - Built-in auth with OAuth2 providers - Admin dashboard for managing collections (tables) and data - Realtime subscriptions via Server-Sent Events - Filterig, sorting, pagination, expand relations — all via URL params - SQLite is fast and reliable for read-heavy apps - Can extend with Go hooks if needed - Tiny resource footprint — runs on 256 MB RAM VPS easily

Weaknesses: - SQLite = single-writer bottleneck (fine for <10,000 concurrent users) - No horizontal scaling (single server only) - Smaller community than Strapi/Directus - No cloud functions or serverless model - Backup = copy the SQLite file (simple but manual)

Best for Recipedia: ✅ Excellent fit. A recipe app with products + translations is well within PocketBase’s sweet spot. You get auth, admin UI, and realtime — all from a 15 MB binary.

2. 📦 Directus

What: Open-source data platform that wraps any existing SQL database with an instant REST/GraphQL API and a rich admin app.

Strengths: - Works with any SQL database — plug it into existing PostgreSQL, MySQL, etc. - Most polished admin UI of the three - Granular role-based permissions - Automation flows (like Zapier inside your backend) - REST + GraphQL simultaneously - Strong TypeScript SDK - Large community and extensive docs

Weaknesses: - Heavier than PocketBase — requires Node.js runtime (~200-400 MB RAM) - Slower to set up (npm install, configure DB, environment vars) - Self-hosting is more involved - Overkill for small projects - The BSL license limits commercial use for large companies

Best for Recipedia: 🟡 Possible but overkill. Would shine if you later need multi-user content management or editorial workflows.

3. 🚀 Strapi

What: Popular headless CMS built on Node.js with a content-type builder, admin panel, and plugin system.

Strengths: - Visual content-type builder — define your recipe schema via the UI - Largest community and plugin ecosystem - Media library for recipe images - Internationalization (i18n) plugin built-in — great for BG/EN/FR - Strapi Cloud offers a free plan (2,500 API requests/month) - Excellent for content-heavy apps

Weaknesses: - Heaviest of the three — minimum 512 MB RAM, ideally 1 GB+ - Slow startup time (~10-30 seconds) - Node.js dependency - Strapi Cloud free tier is very limited (500 DB entries, 2,500 requests/month) - Self-hosting requires managed DB or local SQLite - Can be complex to customize deeply

Best for Recipedia: 🟡 Good if you want a CMS-like experience with i18n built-in, but resource-heavy for a simple recipe app.

Lightweight Backend Comparison

Lightweight Databases (Stand-alone)

If you prefer to use a lightweight database without a framework like PocketBase, here are the options:

For Recipedia, SQLite (via PocketBase or Turso) or PostgreSQL (via managed services) are the most relevant choices.

Free Hosting Platforms

Where to host your lightweight backend for free (or nearly free):

1. 🟢 PocketHost (PocketBase-specific)

Why it’s great: Deploy PocketBase in 30 seconds. No Docker, no VPS, no config. Just sign up and you get a PocketBase instance with a URL. Perfect for prototyping and small apps.

Limitation: 100 MB storage on free tier, but more than enough for a recipe app.

2. 🔵 Render

Strengths: - Simple deploy from Git or Docker - Free PostgreSQL database (90-day limit) - Good for Node.js apps (Strapi, Directus) - Auto-deploy on git push

Weaknesses: - Free services spin down after 15 min → cold starts of 30-60 seconds - Free PostgreSQL deleted after 90 days - No persistent disk on free tier - Not ideal for PocketBase (SQLite needs persistent disk)

[!WARNING] The 90-day database expiry and spin-down behavior make Render’s free tier unsuitable for always-on production apps.

3. 🟠 Railway

Strengths: - One-click database provisioning - Very developer-friendly UI - Easy deploy from Git - Good networking between services

Weaknesses: - No permanent free tier — trial credits only - $5/month minimum after trial - Can be cost-effective though ($5 covers most hobby apps)

4. 🟤 Fly.io

Strengths: - Deploy globally (multiple regions) - LiteFS for distributed SQLite - Great for PocketBase deployments - Very fast networking

Weaknesses: - No real free tier for new users (2025+) - Requires credit card - More complex CLI-based deployment - Usage-based pricing can be unpredictable

5. 🟣 Oracle Cloud Free Tier (Always Free)

Strengths: - Genuinely free forever — not a trial - ARM instances are incredibly generous (up to 24 GB RAM) - 200 GB storage — more than any other free tier - Full VMs — run anything (PocketBase, Docker, PostgreSQL) - Autonomous Database (managed Oracle DB) included

Weaknesses: - Signup can be difficult (rejections common) - Oracle Cloud UI is complex - Requires VPS management knowledge (SSH, firewall, etc.) - Idle VMs may be reclaimed (controversial policy) - Smaller community for web dev use cases

[!TIP] If you can get an Oracle Cloud account, the ARM free tier is absurdly powerful — you could run PocketBase, PostgreSQL, and a full Node.js app simultaneously with 24 GB RAM.

Hosting Platform Comparison

🎯 Final Recommendation for Recipedia

Why PocketBase + PocketHost Wins:

1. 30-second deploy — no Docker, no build, no config
2. Admin dashboard for managing recipes, products, translations
3. Built-in auth — add user accounts later
4. Realtime — live updates when data changes
5. Free — PocketHost free tier is enough for a recipe app
6. Keep Netlify — your frontend stays on Netlify, PocketBase handles the API
7. SQLite — perfect for a recipe app’s data volume

graph LR
    A[Browser] -->|Static Files| B[Netlify CDN]
    A -->|API Calls| C[PocketBase on PocketHost]
    C -->|SQLite| D[Recipes + Products + Users]
    C -->|Realtime SSE| A