Enter Mealie. It's a self-hosted recipe manager and meal planner built for privacy and control. It's the perfect addition to the sovereign homestead's digital toolkit, putting your culinary data back where it belongs: under your ownership.

Why Self-Host Your Recipes?

Before we dive into the "how," let's cover the "why." As a Bitcoiner or Monero enthusiast, you already understand the principles:

• Data Ownership: Your recipes, meal plans, and shopping lists are your data. With Mealie, they are stored in a database you control, on hardware you control. No company can mine this data, sell it, or lock you out of your own account.
• Privacy: No tracking pixels, no analytics, no "smart" recommendations based on your dietary habits. Your cooking habits remain private.
• Censorship Resistance: Your service can't be de-platformed. As long as your server runs, Mealie runs.
• Offline-First Mindset: Hosted on your local network, Mealie is fast and accessible even when your internet connection is flaky. It's a truly resilient system.
• Customization and Control: You control the environment, the backups, and the integrations.

Installing Mealie with Docker Compose

For a bare metal server, Docker Compose is the cleanest and most manageable way to deploy Mealie. It isolates the application and its dependencies, making updates and maintenance straightforward.

This guide assumes you have a server running a Linux distribution with Docker and Docker Compose installed.

Step 1: Create the Project Directory

SSH into your server and create a dedicated directory for Mealie.

mkdir mealie
cd mealie

Step 2: Create the ,docker-compose.yml, File

This file defines the Mealie service and its configuration. Create a new file named docker-compose.yml and paste the following content into it.

version: '3.8'

services:
  mealie:
    image: hkotel/mealie:latest
    container_name: mealie
    restart: unless-stopped
    ports:
      - "80:80" # Exposes Mealie on port 80. Change if needed.
    volumes:
      - ./data:/app/data/ # Persists all Mealie data.
    environment:
      # 
      # Using SQLite is the simplest for a single-user setup.
      # For multi-user or more robust setups, consider PostgreSQL.
      DB_TYPE: sqlite
      # 
      # The default API token for the initial setup. Change this immediately.
      DEFAULT_EMAIL: admin@example.com
      # 
      # Set your initial admin credentials.
      # These are only used on first run if the database is empty.
      # IMPORTANT: Change these before your first run!
      INITIAL_ADMIN_EMAIL: your-admin@email.com
      INITIAL_ADMIN_PASSWORD: your-secure-password

Key Configuration Points:

• ports: This maps port 80 on your host to the Mealie container. If you have another service using port 80 (like a reverse proxy), change the host port (e.g., "8090:80").

• volumes: This is crucial. It maps the ./data directory on your host to the /app/data directory inside the container. This is where all your recipes, user data, and the database will live. Back up this directory regularly.

• environment:

• DEFAULT_EMAIL: This is the default email for API access. It's good practice to set it to your admin email.

• INITIAL_ADMIN_EMAIL & INITIAL_ADMIN_PASSWORD: Change these now. These credentials are used to create the first administrator account the first time Mealie starts up. After the initial setup, these variables are ignored.

Step 3: Launch Mealie

With the docker-compose.yml file in place, you can start the service.

docker-compose up -d

The -d flag runs the container in detached mode (in the background). Docker will pull the latest Mealie image and start the container. This may take a few minutes on the first run as it initializes the database.

Step 4: Initial Setup and Hardening

1. Navigate to http://your-server-ip in your browser.
2. You should see the Mealie setup screen. Create your admin account using the INITIAL_ADMIN_EMAIL and INITIAL_ADMIN_PASSWORD you set in the compose file.
3. Once logged in, immediately go to the Admin Settings and change the default API token (DEFAULT_EMAIL).
4. Explore the settings and configure Mealie to your liking.

Your sovereign recipe manager is now running.

Understanding the Recipe JSON Structure

One of Mealie's most powerful features for the sovereignty-minded is its transparent and structured data format. Recipes are stored as simple JSON objects, making them easy to back up, edit manually, and even script. This is the antithesis of opaque, proprietary formats.

Here is an overview of the main sections in a recipe's JSON structure. You can view this by editing any recipe in Mealie and looking at its raw data.

Core Recipe Object

{
  "name": "Classic Beef Tacos",
  "description": "A simple and flavorful ground beef taco recipe.",
  "image": "images/recipes/12345678-1234-1234-1234-123456789012.jpg",
  "recipeYield": "4 servings",
  "recipeIngredient": [
    "1 lb ground beef",
    "1 packet taco seasoning",
    "1/2 cup water",
    "8 taco shells",
    "1 cup shredded cheese",
    "1 cup shredded lettuce",
    "1 tomato, diced",
    "1/2 cup sour cream"
  ],
  "recipeInstructions": [
    {
      "text": "Brown the ground beef in a skillet over medium-high heat."
    },
    {
      "text": "Drain the excess fat from the skillet."
    },
    {
      "text": "Add the taco seasoning and water to the beef. Stir and simmer until thickened."
    },
    {
      "text": "Warm the taco shells according to package directions."
    },
    {
      "text": "Fill the shells with the beef mixture and top with your favorite toppings."
    }
  ],
  "nutrition": {
    "calories": "350 kcal",
    "proteinContent": "25 g"
  },
  "orgURL": "https://example.com/original-recipe",
  "categories": ["Main Dish", "Beef", "Mexican"],
  "tags": ["quick", "weeknight", "kid-friendly"]
}

Key JSON Fields Breakdown

• name: The title of your recipe.
• description: A short summary or notes about the recipe.
• image: A relative path to the recipe's image file, stored within your ./data volume.
• recipeYield: How much the recipe makes (e.g., "4 servings", "1 loaf").
• recipeIngredient: An array of strings, where each string is a single ingredient. This is perfect for parsing into a shopping list.
• recipeInstructions: An array of instruction objects. Each object has a text field containing a step. This structured approach is far superior to a single block of text.
• nutrition: An object containing nutritional information like calories, protein, fat, etc. All are optional.
• orgURL: If you imported the recipe from a website, Mealie keeps a link to the original source.
• categories: An array of strings for broad categorization (e.g., "Dessert", "Dinner").
• tags: An array of strings for more specific, searchable tags (e.g., "gluten-free", "spicy", "grilling").

This simple, human-readable structure is the foundation of Mealie's power. You can export your entire recipe collection as a single JSON file, providing a true, vendor-agnostic backup of your culinary knowledge.

The first piece of our infrastructure is a personal database running on a server that you control. Think of this as your digital filing cabinet, sitting right in your own home or office.

• What it is: We'll use a database server called CouchDB. It's lightweight, reliable for storing documents, and designed for replication—the perfect partner for syncing your notes.
• How it's hosted: You will run CouchDB on your own server. This could be a spare desktop computer, a dedicated small-form-factor PC, or a single-board computer like a Raspberry Pi. The key is that the hardware is yours.
• How it's secured: This is where we break from traditional methods. Instead of dealing with public IP addresses, domain names, and complex HTTPS certificates, we will use Tailscale. Tailscale creates a private, encrypted network between your devices, kind of like your own personal internet. Your laptop and your office server will be on this "Tailnet," allowing them to communicate securely without ever exposing your database to the public internet.

The outcome of this stage is a secure, always-on database running on your own hardware, accessible only to you.

Part 2: The Private Bridge – Connecting Obsidian via Tailscale

With a secure filing cabinet in place on your Tailnet, the next step is to connect your Obsidian vault to it. This bridge uses your private Tailscale network, making the connection both simple and incredibly secure.

• The Tool: We will use the "LiveSync" plugin for Obsidian. This is the specialized tool that knows how to talk to a CouchDB database.
• The Concept: After you've installed Tailscale on both your writing computer and your server, they can see each other using simple, private names. LiveSync will connect to your CouchDB instance through this secure Tailscale tunnel. It works in the background, automatically sending any new notes or changes you make in Obsidian directly to your server.
• The Magic of Sync: This remains a two-way street. It keeps your local vault and the remote database perfectly in sync. Whether you edit on your laptop or a desktop in another room, LiveSync ensures all your data is consistent and backed up on your own server, all traffic protected by Tailscale's end-to-end encryption.

The outcome of this stage is a continuously backed-up Obsidian vault, with your data flowing securely over a private network to your own physical hardware.

Part 3: The Public Megaphone – Publishing from Obsidian to Nostr

Your thoughts are now safe, synchronized, and completely under your control on your own infrastructure. The final step is to turn select parts of that private vault into a public broadcast for the decentralized web.

• The Plugin: We will install the "Nostr Writer" plugin into Obsidian. Its sole purpose is to format your notes and publish them to the Nostr network as permanent articles.
• The Protocol: Nostr is a decentralized, censorship-resistant social protocol. When you publish, your content is distributed across thousands of relays run by different people around the world. It effectively cannot be de-platformed or removed.
• The Workflow: The process is beautifully simple. You write an article within your synced vault. You add a small block of metadata at the top of the note (called frontmatter) to specify its title, summary, and tags. Then, with a single command from within Obsidian, the Nostr Writer plugin sends that note out to the Nostr network as a long-form, immutable event.

The outcome is the ultimate goal: a thought born in your private mind, organized in your private vault on your private network, is now broadcast to the entire world as a permanent public record—all on your own terms and without ever leaving the comfort of your editor.

Conclusion: You Hold the Hardware and the Keys

By leveraging your own server and the simplicity of Tailscale, you have built a system that is the epitome of data sovereignty. Your work is private by default, backed up on hardware you own, and instantly publishable on your own terms. You are no longer just a writer; you are the master of your digital domain, from the steel of your server to the fabric of the decentralized internet.