How to Build a Digital Cookbook in Markdown

A digital cookbook in markdown is a folder of plain-text files, one recipe per file, each with the same template: a title, a yield line, a tag block, an ingredient list, numbered steps, and notes. No app owns it. No subscription gates it. You can scale it, search it, and read it on any device in any decade.

The recipe is the most structured document an ordinary person writes — a yield, a timed sequence, a measured ingredient list — and the web has spent twenty years burying it. AllRecipes serves more than 50 million monthly visitors, and the dominant format on every one of those pages is a thousand-word story stacked on top of the recipe.¹ Brecht of Bootstrapped Ventures explains the mechanism without apology: "Detailed narratives help to keep people on the page longer, which is a good signal to search engines that your content is valuable."² Cooks answered with extensions. Recipe Filter, an open-source tool that hides the story and surfaces the recipe card, has been forked 55 times on GitHub and detects recipes by scanning for the same itemtype markup the schema standard defines.³ A markdown cookbook skips the war entirely. The story, if you want one, is a single line of notes. The recipe is the file.

Why a recipe belongs in plain text

A recipe belongs in plain text because a recipe is data, not prose. It has a fixed shape — yield, ingredients, ordered steps — that reads the same in 2026 or 2056. The U.S. Copyright Office confirms it: "A mere listing of ingredients is not protected under copyright law."⁴ The structure is free; only the writing around it is owned.

That fact is the whole permission slip for a personal cookbook. You may copy any recipe's ingredients and method into your own file, rewrite the directions in your own words, and keep them forever. What you cannot copy is the blogger's headnote — and the headnote is exactly the part you did not want. Samin Nosrat, who built Salt, Fat, Acid, Heat on the argument that understanding beats instruction, puts the deeper point this way: "recipes lead us to believe that cooking is a linear process, while most good food results from a circular one; like a spiderweb, touch one part and the entire thing will quiver."⁵ A plain-text recipe is honest about this. It is a starting point you annotate, not a contract you obey. Every time you cook it, you edit it. The file gets better; the printed card never would.

The folder structure for a digital cookbook

Use one folder per category and one file per recipe. Six folders carry a working kitchen for years: mains, sides, baking, sauces, drinks, and basics for the techniques you reuse. A seventh, meal-plans, holds weekly plans that link to the recipes. Filenames are lowercase, hyphenated, and human-readable, so any file manager sorts them and any search finds them.

cookbook/
├── mains/
│   ├── roast-chicken-and-lemon.md
│   ├── weeknight-dal.md
│   └── mushroom-ragu.md
├── sides/
│   ├── garlic-greens.md
│   └── smashed-potatoes.md
├── baking/
│   ├── no-knead-bread.md
│   └── olive-oil-cake.md
├── sauces/
│   ├── salsa-verde.md
│   └── quick-tomato.md
├── drinks/
│   └── ginger-switchel.md
├── basics/
│   ├── chicken-stock.md
│   └── pizza-dough.md
├── meal-plans/
│   └── 2026-W23.md
└── templates/
    └── recipe.md

This is the same shape the plain-text recipe community already uses. Cooklang, an open-source recipe markup language maintained since 2021, organizes recipes as individual text files and describes itself as "a simple, human-readable text format for writing recipes that can be understood by both cooks and computers."⁶ The folders carry the coarse sort — what kind of dish — and the tag block inside each file carries the fine sort, the cross-cutting facts a folder cannot express. A weeknight vegetarian curry lives in mains/ and is found again through its tags. The directory is the index every operating system already gives you for free.

The one recipe template

One template carries every recipe in the cookbook. It opens with a yield and timing line, then a tag block, then an ingredient list, then numbered steps, then notes. The fields map one-to-one to the way you actually read a recipe at the counter — how much it makes, what to buy, what to do, what went wrong last time.

Keep the template in templates/recipe.md and copy it for each new dish. The fixed field order is the entire point: once your eye learns where the yield lives, you find it on every recipe without reading.

# {{Recipe name}}

**Yield:** 4 servings · **Prep:** 20 min · **Cook:** 40 min · **Total:** 1 hr
**Source:** where it came from (a person, a book, a URL, or "mine")
**Tags:** #mains #vegetarian #weeknight #one-pot #make-ahead

## Ingredients
- 2 cups (240 g) flour
- 1 tsp fine salt
- 400 ml coconut milk
- 1 medium onion, diced

## Steps
1. Do the first thing. Name the pan and the heat.
2. Do the second thing. Give a sensory cue, not just a time.
3. Finish. Say how to know it is done.

## Notes
- What you would change next time.
- A substitution that worked.
- The serving it pairs with → [[garlic-greens]]

Three rules make this template earn its place. First, the Source line is non-negotiable — a recipe with no provenance is a recipe you cannot fix, because you cannot return to the original. Second, every step gets a sensory cue, not only a clock reading: "until the onions are translucent and smell sweet," not "after 8 minutes." Nosrat's entire method rests on this distinction — "In order to cook instinctually, I needed to learn to recognize these signals."⁵ Third, the Notes block is where the file outgrows its source. The first time you cook it, you write one line. By the tenth time, the notes are the most valuable part of the page.

Formatting ingredients and steps

Format ingredients as an unordered list and steps as an ordered list — always. The two list types are not decoration. They encode meaning: ingredients are a set you gather in any order, and steps are a sequence you follow in order. Markdown's - and 1. say exactly that, and every parser reads it.

Write each ingredient as one line in a fixed order: quantity, unit, item, then preparation. "2 cups (240 g) flour" gives volume and weight, because baking needs weight and the rest of the kitchen thinks in cups. Put the cut after a comma — "1 medium onion, diced" — so the shopping eye reads "onion" and the cooking eye reads "diced." For steps, one action per number, and never bury two actions in one line; the numbered step is the unit a cook checks off, and a step that does two things gets half-done. Cooklang formalizes this instinct at the token level, tagging ingredients inline as @flour{2%cups} and timers as ~{25%minutes} so a parser can lift quantities and build a shopping list automatically.⁶ You do not need that machinery to benefit from its discipline. A clean list and a clean sequence carry ninety percent of the value with none of the syntax.

Tags that replace a search you would otherwise forget

Tags answer the questions a folder cannot. A recipe lives in exactly one folder but belongs to many searches: the vegetarian search, the thirty-minute search, the uses-up-the-spinach search. A small, controlled tag vocabulary turns every one of those into a one-line query, and the controlled part matters more than the tags themselves.

Pick four tag axes and stop. Diet (#vegetarian, #vegan, #gluten-free), effort (#weeknight, #project, #one-pot), occasion (#breakfast, #crowd, #holiday), and season (#summer, #winter). Decide singular-or-plural and hyphenation once — #make-ahead, never also #makeahead and #make_ahead — because a tag that exists in three spellings is three tags that each find a third of your recipes. Steph Ango, who maintains his whole note system this way, avoids folders and leans on metadata and links instead: "Most of my notes are in the root of the vault, not a folder," and "I use internal links profusely throughout my notes."⁷ A tag is a saved search you wrote before you needed it. The day you have forty recipes, the tag block is the difference between cooking and scrolling.

Scaling a recipe for a different number of servings

Scaling is why the yield line sits at the top of the template. To double a recipe, you multiply every ingredient quantity by two and leave the steps alone — but two caveats save the dish. Cooking time scales with depth and surface area, not with volume, and seasoning scales sublinearly: taste before you add the last of the salt.

A markdown cookbook gives you two ways to scale, and you should know both. The manual way: read the yield, pick your multiplier, and rewrite the ingredient quantities into the Notes block as a scaled variant ("× 1.5 for 6: 3 cups flour, 600 ml coconut milk"). It is thirty seconds and it is permanent. The automated way is why dedicated recipe managers still exist: Paprika, a recipe app sold as a one-time purchase per platform (about $5 on mobile, more on desktop) with no subscription, will "automatically scale ingredients to your desired serving size" the moment you change the yield.⁸ If you scale constantly, that convenience is real. If you scale a recipe a handful of times in its life, the manual note in plain text outlives the app that did the math. The structured ingredient line — quantity first, always — is what makes either path possible. A vague "some flour" cannot be doubled by anyone, human or machine.

Searching a cookbook you cannot remember writing

A plain-text cookbook is searchable by definition: every recipe is text, and text search is a feature every editor, file manager, and operating system already ships. To find every recipe that uses anchovies, you search "anchovies." To find every thirty-minute vegetarian main, you search the tag #weeknight inside mains. The structure you imposed at write-time makes the read-time search precise.

This is the quiet advantage over the recipe-app model. AllRecipes and the food-blog web are searchable only through their own boxes and only across their own content; your own modifications, your own notes, your own substitutions never enter the index because they never existed.¹ A markdown cookbook indexes the part that matters most — the line in the Notes block where you wrote "halve the chili, the kids revolted." Markdown is built for exactly this kind of low-friction, plain-language ownership; if the syntax itself still feels foreign, the case for it is its own short post: Markdown for People Who Don't Code. Search rewards the cook who wrote one clean line per step, because the search returns the line, not a wall of prose wrapped around it.

Make each recipe machine-readable with Recipe schema

A single optional block turns each markdown recipe into a file machines can read: a Recipe schema object. Schema.org defines Recipe as a subtype in the hierarchy Thing > CreativeWork > HowTo > Recipe, with named properties for recipeIngredient, recipeInstructions, recipeYield, prepTime, cookTime, and totalTime.⁹ It is the same vocabulary the entire recipe web already speaks.

You do not need this to cook. You need it the day you publish a recipe, hand your cookbook to another app, or want a tool to lift the ingredients into a shopping list without guessing. Google's own guidance is plain: "Use Recipe structured data for content about preparing a particular dish," and it requires only two properties to be valid — name and image.¹⁰ The recipe-extraction extensions cooks already rely on lean on exactly this markup; Recipe Filter finds the recipe on a page by scanning for itemtype declarations, the microdata twin of the same schema.³ Below is the JSON-LD form of the roast-chicken file above — durations in the ISO 8601 format the standard expects (PT20M, PT40M, PT1H).

This block is optional, and most home cooks will never write one by hand. The point is that the structure was there all along. A markdown recipe with a yield line, an ingredient list, and numbered steps already is a Recipe object — the JSON is only that same shape, declared. The plain file is the source of truth; the schema is a view.

Pitfalls common to recipe collections

The recurring failure of a personal cookbook is not too few recipes — it is the recipes you can no longer trust. The four pitfalls below each break trust differently: a recipe with no source you cannot verify, one with no notes you keep cooking wrong, an inconsistent template you cannot scan, a tag sprawl you cannot search.

1. No source line. A recipe copied with no provenance is an orphan. When it tastes off, you cannot return to the original to see what you mistyped. Always record where it came from, even if the answer is "mine."
2. No notes after the first cook. The first version of any recipe is a guess. The cook who never updates the Notes block re-makes the same mistake annually. One line after each cook compounds into the most valuable file in the folder.
3. Template drift. If half your recipes put the yield at the top and half bury it in prose, you have to read each one to use it. Copy the template every time. Consistency is what lets your eye skip to the field it wants.
4. Tag sprawl. Forty recipes with sixty one-off tags is sixty searches that each return one result. Hold the vocabulary to four axes and a fixed spelling.⁷ A tag is only useful if it groups.

There is a fifth, quieter pitfall: writing the blog headnote you came here to escape. Your Notes block is not a story. It is a list of corrections. Keep it that way and the cookbook stays a tool.

Frequently asked questions

Five questions surface for almost everyone building a plain-text cookbook — about app choice, importing from the web, scaling, photos, and whether the schema block is worth the trouble. Each answer carries the working consensus from the tools and sources cited above.

Do I need a special app to keep a markdown cookbook?

No. Any editor that opens plain text and renders markdown will do. Dedicated managers like Paprika add a built-in browser clipper and automatic scaling for a one-time purchase per platform.⁸ Cooklang adds machine-parseable ingredient syntax.⁶ But the files are the cookbook, and a folder of markdown recipes opens in any editor, on any device, with no install and no account.

How do I get a recipe off a blog into my cookbook?

Copy the ingredient list and the method, then rewrite the directions in your own words. The U.S. Copyright Office is explicit that "a mere listing of ingredients is not protected under copyright law," so the structure is yours.⁴ Leave the headnote behind — it is the part you wanted to skip. Record the original URL in the Source line.

How do I scale a recipe up or down in plain text?

Multiply every ingredient quantity by your target multiplier and save the result as a labeled variant in the Notes block. Leave the steps unchanged, but adjust cooking time by depth, not volume, and taste before the final seasoning. A structured ingredient line — quantity first — is what makes scaling possible, by hand or by an app like Paprika.⁸

Can I put a photo of the dish in a markdown recipe?

Yes. Markdown supports images with one line: ![Finished roast chicken](roast-chicken.jpg), with the photo kept beside the recipe. For a digital cookbook you own, one photo per recipe is plenty — the dish as it should look when done. The Recipe schema standard treats image as one of only two required properties.¹⁰

Is the Recipe schema block worth writing?

Only if you publish or hand your cookbook to another tool. For private cooking, a yield line, an ingredient list, and numbered steps are enough — and they already are a Recipe object in everything but syntax. Schema.org places Recipe under Thing > CreativeWork > HowTo > Recipe, so a markdown recipe maps onto it the day you need it.⁹

The cookbook is the file

A digital cookbook in markdown sits alongside Paprika, Cooklang, and the recipe web, not against them — it is the version you still own once the app is gone. The recipe was always structured data wearing a story. Strip the story, keep the structure, and the file is a cookbook any machine can read for as long as text exists.

The same plain files open in any markdown editor that renders lists and links — mnmnote.com is one that runs in a browser tab with no account and no install.

References