What is a Life OS, and do you need an app or a Notion template?

The test that separates them: does it run?

An operating system that does not run is not an operating system; it is a filing cabinet with a nice login screen. The honest test for anything calling itself a Life OS: if you stopped feeding it for two weeks, would anything happen next Sunday? Would it surface the renewal that is now six weeks out, draft the week around the deadline it knows about, ask you to review anything? Or would it simply hold what you last typed, unchanged, while your actual week ran on reaction?

Most of what carries the Life OS name today is static. Beautifully organised, genuinely useful for remembering, and inert. The archive grows; the week does not change. What running looks like in practice is a loop with a rhythm: capture what lands, notice what matters on a schedule, shape a week from it, review the draft, learn from what happened, repeat. That loop is a method, not a product, and it has its own guide: the notice loop. Whatever you build or buy, the loop is the part that makes it an OS rather than an archive; a system runs when the loop runs.

The frameworks a Life OS is built from

Underneath every serious system, built or bought, you find the same handful of named ideas doing the structural work. Knowing them saves you from reinventing them badly.

Getting Things Done (David Allen) contributes capture and the weekly review: get everything out of your head, look at it on a rhythm. PARA and Building a Second Brain (Tiago Forte) contribute the storage architecture: organise notes by actionability, not topic. The Zettelkasten tradition contributes networked thinking, best for ideas and writing. The bullet journal (Ryder Carroll) contributes migration, the hand-run habit of re-deciding what deserves to move forward. Pillars, Pipelines and Vaults (August Bradley) is the most complete Notion-native life-OS methodology, linking life areas to goal pipelines to knowledge, and it is honest about demanding real upkeep. TELOS (Daniel Miessler) contributes the purpose layer: problems, missions, goals and metrics written down so a system, or an AI, knows what it is all for.

None of these is a Life OS by itself. They are the organs: capture discipline, storage, thinking, re-deciding, purpose. What turns organs into an organism is the running loop from the previous section, and that is the piece most stacks are missing.

Building your own: an honest starter

If you want to build, build. A hand-built Life OS teaches you what you actually need, costs nothing but time, and keeps every file yours. The mistake is starting with forty databases. Start with the minimum viable system: one inbox, one calendar, one weekly page, one standing half hour on Sunday. That is genuinely all a running Life OS requires on day one; everything else is elaboration you add when a real need appears, not before.

Where to build it: plain markdown files if you want maximum ownership and portability (a folder, a text editor, done), Obsidian if you want links and search over those same files, Notion if you want databases and don't mind the company's servers holding the content. Each route now has a full build guide in this library, and every template they use is in the free pack. The structure matters less than the rhythm: the folder sketch below runs identically in all three.

Two warnings from everyone who has built one. First, resist reorganising: the system exists to run your week, and every hour spent redesigning folders is an hour the loop did not run. Second, write the weekly page every week even when the week went badly; a Life OS with gaps where the hard weeks were is a highlight reel, and highlight reels teach you nothing.

# A minimum viable Life OS

## The structure (three folders, one page)

    life/
      inbox.md          <- everything lands here, one line each, no sorting
      areas/            <- one note per life area, only when one earns it
        health.md
        money.md
        people.md
      weeks/            <- one page per week, from the template below
        2026-W31.md

## The weekly page (copy into weeks/ each Sunday)

    # Week of ____________

    ## Noticed this Sunday (from inbox + next 4 weeks of calendar)
    -

    ## This week's plan (3 to 5 priorities, placed and sized honestly)
    1.
    2.
    3.

    ## Learned (one line, end of week)
    -

## The rhythm (this is the OS part)

    - Capture into inbox.md the moment things land, all week
    - Sunday, 30 minutes: read inbox, scan 4 weeks ahead, write the weekly page
    - End of week: one Learned line
    - Next Sunday: read last week's Learned line first

Full method: asambl.app/guides/the-notice-loop/

What building really costs

The build is the cheap part. The cost of a hand-built Life OS is the tending: an hour or two a week keeping structure current, fixing what drifted, resisting the redesign itch, plus the Sunday half hour that does the actual running. For some people that tending is a pleasure and genuinely part of the point. If that is you, build without guilt; you are not doing it wrong.

The failure pattern to watch for is building high and maintaining low: three weekends of architecture, then a system too elaborate to feed on a Tuesday, then quiet abandonment around week six, then a new template. If you have run that cycle more than once, the lesson is not that you lack discipline. It is that the maintenance bill was set higher than your real week could pay, and the next system should be smaller, not cleverer.

Templates and apps, without the strawmen

Bought templates deserve a fair reading. A good one, and the best Notion builders are genuinely good, hands you a working architecture on day one and skips a month of design. What no template can sell you is the running: the scheduled noticing, the weekly drafting, the review. Those recur, and they recur as your labour. A template is a head start on structure, not an engine, and the graveyard of abandoned Life OS templates is mostly people who bought architecture expecting an engine.

A purpose-built app takes the opposite trade. You give up structural freedom and get the engine: the app runs the loop, and your job narrows to the decisions. What to demand before trusting one: that it actually runs (scheduled noticing and drafting, not just storage with reminders), that it covers the whole of life rather than only work, that your data stays yours in portable files, and that any AI in it is optional and reviewable rather than autonomous. Those four criteria apply to every app in the category, including ours.

asambl is built as exactly this trade: a second-brain foundation (your notes, files and journal, kept as portable files on your computer) with a planner that runs the notice loop on top: a drafted week and a quarterly plan you review and approve, across work, health, money, relationships, joy, and growth. When AI is on, only the information needed for that specific request leaves your machine, and AI can be switched off entirely. That is one implementation of the criteria, stated once; the criteria matter more than the name on the app.

Build, buy, combine, or keep it simple

The honest decision tree, with no rhetorical thumb on the scale:

• Build if: you enjoy tending systems, your needs are unusual, you want every file yours forever, and an hour or two a week of upkeep reads as craft rather than tax. Start from the starter above, not from forty databases
• Buy a template if: you want working architecture on day one inside a tool you already live in, and you accept that the weekly running stays your labour. Pick one small enough to feed on your worst week
• Buy an app if: you want the outcome (a coordinated, reviewed week) more than the ownership of the structure, and the app passes the four criteria: it runs, it covers life not just work, your data stays portable, AI stays optional
• Combine if
  • you already have a second brain that works. Keep it for knowledge and add a running planner beside it
  • the two jobs are different and nothing forces them into one tool
• Keep it simple if
  • reading this list felt heavy. One inbox, one calendar, one weekly half hour is a complete Life OS. Scale is not the point
  • the loop is