Mealie - Your Sovereign Recipe Manager for a Self-Hosted Kitchen

For those of us who value sovereignty in our digital lives, the control extends beyond our finances into our daily tools. We run our own nodes, manage our own keys, and seek to minimize our reliance on third-party services. Yet, a seemingly mundane part of life—managing recipes—often remains shackled to cloud services, tracking, and proprietary platforms.

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.