The Problem: Note-Processing Overhead That Doesn't Pay Off
You save an article. You know you should process it into proper notes — extract the key ideas, write them in your own words, link them to related notes. But you have 200 articles saved. Processing all of them would take weeks. And most of them you'll never actually need.
This is the over-processing problem: productivity systems that require extensive upfront processing of every captured item don't scale. The more you capture, the more you fall behind on processing. The processing backlog grows, the guilt accumulates, and the system eventually collapses into a pile of unprocessed captures.
Just-in-time note-taking is a contrasting principle: process notes at the moment they become relevant to current work, not immediately after capture. Your saved article sits unprocessed until you actually need it — at which point you invest the processing effort, because now you know the effort will pay off.
Where Just-In-Time Note-Taking Comes From
The "just-in-time" concept originates in manufacturing, specifically Toyota's Toyota Production System (TPS) (developed 1940s-1970s), where "just-in-time" production means manufacturing exactly what's needed, exactly when it's needed — eliminating inventory buildup that represents unrecovered investment in material that may never be used.
In knowledge management, the term was applied by Tiago Forte (creator of Building a Second Brain) to the practice of progressive summarization. Forte explicitly describes the "just-in-time" approach to note processing: rather than summarizing every note immediately after saving (just-in-case), you summarize notes the next time they become relevant to a project (just-in-time). This ensures processing effort is invested only in notes that demonstrate usefulness by actually being needed.
Related principles from software engineering:
- YAGNI ("You Ain't Gonna Need It"): don't build features speculatively; build what's needed when it's needed
- Lazy evaluation: defer computation until its result is actually needed
Applied to notes: don't process captures speculatively (just in case); process them when they're actually needed (just in time).
The principle appears in several PKM frameworks:
- Tiago Forte's progressive summarization uses just-in-time processing explicitly
- Andy Matuschak's approach to evergreen notes emphasizes processing when ideas become relevant
- Sönke Ahrens' Zettelkasten workflow allows literature notes to sit until they're processed into permanent notes during a writing project
The Just-In-Time Note-Taking Method, Step by Step
Step 1: Capture Liberally, Without Processing
The first principle of just-in-time note-taking: capture freely at the point of encounter, with minimal or no processing.
Capture mechanisms:
- Web clipper (saving articles, passages, web pages)
- Read-it-later queue (Pocket, Instapaper, Readwise Reader)
- Voice memos (ideas while mobile)
- Quick text capture (phone notes, paper)
- Highlights in Kindle or PDF reader
What "no processing" means:
- Don't immediately extract key ideas
- Don't immediately write things in your own words
- Don't immediately link to related notes
- Just save it, with minimal tagging or organization
The capture is an investment that may or may not pay off. You're not processing the investment yet.
Step 2: Maintain a Lightweight Capture Inbox
Your captures accumulate in an inbox. The inbox should:
- Be easily scannable
- Show you what you have without requiring you to process it
- Be searchable (so you can find relevant captures when a project starts)
This is the complement to just-in-time processing: you're not organizing everything, but the inbox is searchable enough that you can find relevant captures when you need them.
Step 3: Process Notes When Projects Demand Them
When you start a new project, research task, or writing assignment:
- Search your captures for relevant material
- For each relevant capture: process it now — extract key ideas, write in your own words, link to related notes, incorporate into the project
This is the just-in-time moment: you're investing processing effort because you know the note will be used.
The key insight: Notes you process for a current project are worth far more than notes you might process just in case. The project gives you a context for processing — you know which ideas are important, which connections matter, and how the material will be used.
Step 4: Let Irrelevant Captures Expire
Notes that are never retrieved — never needed for any project — don't need to be processed. They sit in the capture inbox until they expire.
When to purge: Set a periodic (monthly or quarterly) inbox purge. Delete captures older than your purge threshold that haven't been accessed. Or simply let the inbox grow and trust search to surface what's needed.
The emotional shift: you don't feel guilty about unprocessed notes because the whole point is that they're unprocessed until needed. If they're never needed, they were low-value captures — and the time saved by not processing them was well spent.
Step 5: Build a Processed Note Archive Over Time
Notes you process during projects don't go back to the unprocessed inbox — they go into your processed note archive (your Zettelkasten, evergreen notes system, or equivalent).
Over time, frequently relevant topics develop rich processed note archives — because they've been needed in multiple projects. Less-needed topics remain mostly unprocessed in the capture inbox. The structure emerges organically from your actual use patterns.
A Worked Example
A freelance content strategist, Maya, applies just-in-time note-taking:
Capture phase (ongoing, 6 months):
Maya clips 4-6 articles per day to her WebSnips collections and Readwise inbox. She does almost no processing. Her capture inbox has 600+ items after 6 months.
Project begins: "Email marketing for B2B SaaS guide"
Maya searches her inbox for "email," "B2B," "marketing automation," "conversion rates." She finds 23 relevant articles she'd saved over the past 6 months.
Just-in-time processing (during the project):
For each relevant article:
- Reads it now (not when she saved it — now, when she knows it's needed)
- Extracts 1-3 key ideas
- Writes brief evergreen notes on each idea
- Links to related notes from other processed articles
By the end of the project, 23 captures have become 40 processed notes — a rich archive of B2B email marketing knowledge.
6 months later, starting another B2B email project:
The 40 processed notes are immediately useful. Maya also searches the (now 900+ item) unprocessed inbox for new captures on the topic. She processes the relevant new ones just-in-time.
Over time: her most-used topics have rich processed note archives; her less-used topics remain mostly unprocessed in the inbox, available for future projects.
Just-In-Time vs. Just-In-Case Note-Taking
| Approach | When to process | Overhead | Best for |
|---|
| Just-in-case | Immediately after capture | High (scales with capture volume) | Small capture volume; deep-learning focus |
| Just-in-time | When notes become relevant to current work | Low (scales with project count) | High capture volume; project-driven use |
The critical tradeoff:
- Just-in-case processing ensures no insight is lost due to delayed processing, but creates a processing burden that limits capture volume
- Just-in-time processing allows high-volume capture but accepts that some captures will never be processed
For most knowledge workers and content creators who capture many sources, just-in-time is more sustainable. For researchers who need to be comprehensive, just-in-case processing of selected high-value sources is preferable.
Where Just-In-Time Note-Taking Shines
For high-volume capturers: People who save dozens of articles per week can never process everything just-in-case. Just-in-time scales to any capture volume.
For project-driven knowledge workers: If your work is organized into projects (consulting engagements, content series, research papers), just-in-time processing aligns naturally — each project triggers processing of relevant captures.
For reducing perfectionism and guilt: The common PKM affliction — guilt about unprocessed saves, anxiety about the backlog — is eliminated by just-in-time. Unprocessed captures aren't a failure; they're intentional deferrals.
Where Just-In-Time Note-Taking Breaks Down
For time-sensitive material: If a source contains information that will be less relevant or accurate over time (news, current market data, rapidly evolving tech), just-in-time processing may defer until the information is outdated.
For non-project-driven learning: If you're learning for its own sake (not driven by specific projects), just-in-time offers few triggers for processing. The notes stay in the inbox indefinitely.
For systematic literature reviews: Academic research requiring comprehensive coverage of a field can't rely on just-in-time; sources need systematic processing regardless of immediate relevance to a current project.
Tools That Support Just-In-Time Note-Taking
| Tool | Role | Notes |
|---|
| Readwise Reader | Capture inbox with highlights | Strong search; just-in-time processing when exporting to notes |
| Pocket / Instapaper | Article capture inbox | Good for read-it-later; limited note integration |
| Notion inbox | Capture + organized note archive | One app for both inbox and archive |
| Obsidian + inbox folder | Capture folder → permanent notes when processed | Good separation of inbox from processed notes |
| WebSnips | Web capture (capture layer) | Clip and organize captures; search when projects begin |
| Zotero | Academic source capture | Just-in-time when specific papers become relevant |
WebSnips and just-in-time note-taking: WebSnips is naturally a just-in-time capture tool — you clip web content and organize it into collections, and you retrieve and process it when a project demands it. The collection structure (organized by topic) enables the search step: when starting a project on "content strategy," you search WebSnips for relevant clips and process the relevant ones now.
Common Just-In-Time Note-Taking Mistakes
Mistake 1: Confusing "just-in-time" with "never process."
Just-in-time processing means deferring processing until notes are needed — not never processing them. When a project demands a note, process it thoroughly. Just-in-time is a scheduling principle, not an excuse to avoid processing entirely.
Mistake 2: An inbox that's unsearchable.
Just-in-time processing only works if you can find relevant captures when a project starts. If your inbox is unsearchable (no tagging, poor filing, content not indexed), the captures are inaccessible and effectively lost.
Mistake 3: Never triggering processing.
If you never start concrete projects — if you're always in "collecting" mode — just-in-time has no trigger. The method depends on project-driven demand for the knowledge. Without projects, you need a different approach.
Mistake 4: Guilt about the unprocessed inbox.
The unprocessed inbox is not a failure — it's an intentional deferral strategy. Re-framing: your inbox is a searchable reservoir, not a backlog. Process when needed, not because it exists.
Frequently Asked Questions
How big should my capture inbox be before I should worry?
There's no size threshold for concern — the question is whether you can search it effectively. A 5,000-item inbox that's searchable is better than a 100-item inbox that isn't. If your inbox is too large to search effectively, add tagging or categorization at capture time to improve searchability.
When should I choose just-in-time over just-in-case processing?
Just-in-time: when you capture more than you can process, your work is project-driven, and topics of interest are broad. Just-in-case: when your capture volume is manageable, you're deeply learning a specific domain, or you need comprehensive coverage for research.
Does just-in-time work for a Zettelkasten?
Yes — this is how Ahrens implicitly describes Zettelkasten processing in How to Take Smart Notes. Literature notes and fleeting notes are captured freely; they become permanent notes when they become relevant to a current writing project. The slip-box workflow is a just-in-time workflow.
Key Takeaways
- Just-in-time note-taking means processing notes at the moment they become relevant to current work — not immediately after capture.
- Origin: manufacturing principle (Toyota Production System, 1940s-70s) applied to knowledge management by Tiago Forte in the context of progressive summarization.
- Capture freely; process selectively: capture everything that might be relevant, but only invest processing effort in captures that are actually needed.
- The searchable inbox is the infrastructure that makes just-in-time work: captures must be findable when a project starts.
- Projects trigger processing: just-in-time works best when work is organized into projects that create specific demand for knowledge.
- Guilt-free by design: unprocessed captures aren't a backlog failure; they're intentional deferrals — some will be needed eventually, some never.
Conclusion
Just-in-time note-taking is the most realistic approach to knowledge management for people who capture more information than they can process in real time. The core reframe is powerful: instead of feeling guilty about an unprocessed inbox, you see it as a searchable reservoir — available when needed, undisturbed when not. The quality of your processed notes is high because you process them in context (when you know exactly how you'll use the material). The quantity of processing is sustainable because you only process what matters. For knowledge workers, content creators, and PKM practitioners dealing with high-volume capture, just-in-time processing is the most practical path to a knowledge system that grows without collapsing under its own weight.
Try WebSnips free — build a searchable web capture reservoir you can dip into when projects begin, processing specific clips just-in-time rather than immediately after every save.