Most journaling guides tell you to create a new note for every day. Open your app, hit the plus button, get a fresh blank page, write, close it, repeat tomorrow. It sounds tidy. It sounds organized. And for a lot of people, it quietly kills the habit within a few weeks.
There is another way to do this that gets almost no attention: one single text file that just keeps growing. You open the same file every day, scroll to the bottom, type the date, write, and save. No new notes, no folders, no tagging system to maintain. Just one file that becomes a running record of your life, the same way a physical notebook has worked for writers for hundreds of years.
I switched to this method after years of bouncing between note-per-day apps, and it changed how often I actually wrote. Before that, my entries were scattered across three different apps because I kept switching tools, hoping the next one would fix my consistency problem. It never did. Rohan Ratnayake has been exploring and writing about Digital Writing Workflows & Craft for years, bringing research, cultural context, and clear explanations to readers. What fixed my consistency wasn’t a better app. It was removing the decision of where a new entry should live.
What the One-File Method Actually Looks Like
The idea is simple. You create a single plain text file, something like journal.txt or journal.md, and every entry gets appended to the bottom (or the top, depending on your preference) with a date heading above it. There’s no database, no separate note objects, no linking between entries. The whole history of your writing sits inside one document you can open with almost any text editor on any device.
A typical entry might look like this:
## July 12, 2026
Slept badly again. Spent the morning rewriting the intro to the report three times before I let it go. Talked to Mom about the trip in September, she's leaning toward October instead.
You keep adding entries below the last one, month after month, year after year. Some people split by year into separate files once the file gets large. Others keep everything in one file for a decade or more. Either way, the core habit stays the same: one place, no decisions, just write.
Why Note-Per-Day Became the Popular Default
Most journaling apps push you toward one note per day because that’s how modern note-taking software is built. Apps like Day One, Notion, and Obsidian are designed around the idea that each note is its own object with its own metadata, tags, and location. This makes sense for reference notes, project notes, or anything you need to organize by topic.
But a journal isn’t a reference library. It’s closer to a stream. When you split that stream into hundreds of separate daily files, you lose something apps rarely admit: the ability to read your life as one continuous piece of writing.
There are also structural reasons the note-per-day habit stuck around:
- App interfaces are built around calendars, and calendars naturally map to one entry per day.
- Cloud sync services often handle small files more predictably than one giant file.
- Search features in these apps are marketed as solving the problem that one big file supposedly can’t handle.
- New entries feel like a fresh start, which some people find psychologically easier than facing a long, growing document.
These are real reasons. But none of them prove that splitting your journal produces better writing or a habit that actually sticks.
The Case Against Splitting Your Journal
Here’s the argument I’d make against the note-per-day habit, based on years of doing both.
It Breaks Narrative Continuity
When your journal lives in three hundred separate files, you stop seeing your life as a story. You see it as a pile of disconnected fragments sitting in a folder. Reading through a year of daily notes means opening file after file, and most people never actually do this because the friction is too high. A single file, on the other hand, lets you scroll through six months of your life in one continuous motion. You start to notice patterns you’d otherwise miss: the week everything felt heavy, the stretch where you kept mentioning the same project, the slow shift in tone after a big decision.
It Makes Rereading Frictionless
Rereading old entries is one of the most useful parts of journaling, and it’s also the part most people skip. With note-per-day systems, rereading means clicking through a calendar or a file list one entry at a time. With one file, rereading is just scrolling or using your editor’s search bar. You can jump from January to June in seconds. That low friction matters more than it sounds like it should, because the easier something is, the more often you’ll actually do it.
It Mirrors the Notebook Tradition Writers Have Always Trusted
Paper journals have never worked as one-page-per-day objects unless a diary was specifically printed that way. Writers, from Virginia Woolf to working novelists today, have historically filled continuous notebooks, writing forward through the pages without splitting each day into its own separate object. The one-file text approach on a computer is the closest digital equivalent to that habit. It respects how journaling has actually worked for centuries, rather than forcing it into the shape of modern productivity software.
This Isn’t New: The One Big Text File Tradition
The single-file habit didn’t start with journaling apps. It has deep roots in early personal computing and in how programmers have worked for decades.
Long before note-taking apps existed, many programmers kept a single running log file, often literally named something like notes.txt or log.txt, where they recorded what they worked on, bugs they found, and ideas they wanted to revisit. This habit is still common today among developers who prefer plain text over dedicated tools. The reasoning is almost identical to the case for one-file journaling: a single file is portable, searchable with basic tools, free of any app lock-in, and readable in twenty years without needing the original software that created it.
Writers who grew up on early word processors and text editors carried a similar habit. Before syncing services and note apps existed, keeping one big text file was often the only practical way to maintain a long-running document across different computers. You’d copy the file to a floppy disk, then a USB drive, then a cloud folder, and the file itself never changed shape. Only the method of moving it did.
This history matters because it shows the one-file method isn’t a shortcut or a hack. It’s a tested habit that predates modern apps by decades, and it survived because it solves a real problem: keeping long-form writing accessible without needing specialized software to read it.
How to Actually Find Things in a Giant File
The most common objection to this method is search. People assume that without a dedicated app, finding a specific memory or entry becomes impossible. In practice, it’s easier than most people expect, once you build two small habits into your writing.
Use dates as anchors. Every entry starts with a clear date heading, formatted the same way every time (for example, ## July 12, 2026). This consistency means you can jump to any point in time just by scanning for a date pattern, and most text editors let you search for a partial date like “July 2026” to jump straight to that stretch of entries.
Type recurring keywords as personal tags. Instead of a formal tagging system, you naturally reuse certain words when writing about recurring topics. If you’re journaling about a work project, you might always call it by the same short name. If you’re tracking a health habit, you use the same word for it every time. These recurring words work like informal tags. Later, a plain search for that word pulls up every entry where it appears, in the order it happened.
Here’s how this plays out with basic tools:
| Search Need | Method | Tool You Can Use |
|---|---|---|
| Find all entries from a specific month | Search the date pattern | Text editor’s find (Ctrl+F / Cmd+F) |
| Find every mention of a specific project | Search the recurring keyword | Text editor’s find, or grep in terminal |
| Find entries around an emotional theme | Search for words you consistently use for that feeling | Text editor’s find |
| Jump between years | Search for the year number | Text editor’s find |
| Count how often something comes up | Search and use “find all” count | Text editor with match counter |
No app, no plugin, no paid subscription. Just a plain text search bar, which every text editor already has built in.
One File vs One Note Per Day: A Side-by-Side Comparison
| Factor | One Long Text File | One Note Per Day |
|---|---|---|
| Reading your history as a whole | Easy, just scroll | Hard, requires opening many files |
| Search across all entries | One search bar covers everything | Depends on the app’s search quality |
| Portability across devices and apps | High, plain text opens anywhere | Often tied to one app or format |
| Backup complexity | Simple, one file to copy | More files to track and back up |
| Feeling of a “fresh start” each day | Lower, you see the whole document | Higher, each note feels separate |
| Risk of losing years of writing to a single failure | Slightly higher without backups | Lower, damage is limited to one note |
| Setup effort | Almost none | Depends on the app |
| Long-term software independence | High | Depends on whether the app survives |
Neither column is universally better. The right choice depends on how you actually want to read your own writing later, not just how you want to write it now.
When One File Stops Working
Being honest about the limits of this method matters more than selling it as a perfect system, because it isn’t one.
A single file starts to become genuinely uncomfortable to work with once it grows past roughly 5,000 to 10,000 entries’ worth of text, which for most daily journalers works out to somewhere between five and ten years of writing, depending on entry length. At that point, some text editors slow down when opening or searching the file, especially on older phones or lower-powered devices.
The method also stops fitting certain use cases:
- If you need to attach photos, voice memos, or other media directly to entries, a plain text file becomes clumsy fast.
- If multiple people need to write in the same journal at the same time, a single file creates sync conflicts.
- If you need structured data (like mood ratings you plan to graph later), a single free-form file makes that harder to extract cleanly.
- If your writing style produces very long entries, thousands of words at a time, file size grows faster and search becomes slower.
None of these are reasons to avoid starting with one file. They’re signals for when it’s time to change your system, which is exactly what happens next.
How to Migrate to Dated Files Without Losing the Archive
If your single file eventually becomes too large or your needs change, you don’t have to throw away years of writing to switch systems. Here’s a migration path that keeps the archive intact while moving forward with a cleaner structure.
- Keep the original file as a closed archive. Rename it clearly, something like
journal-archive-2019-2025.txt, and stop adding new entries to it. This file stays untouched and searchable forever. - Split the archive into readable chunks if needed. If the single file is very large, break it into year-based files (
journal-2019.txt,journal-2020.txt, and so on) using the date headings as natural split points. This keeps rereading manageable without losing any content. - Start a new system going forward. From this point, switch to one note per day, or one file per month, whichever fits your new use case. The date heading habit you already built carries over directly.
- Cross-reference the switch date in your new system’s first entry. A short note like “Continuing from the archive file, entries before this are in journal-archive-2019-2025.txt” keeps future-you oriented if you ever need to find something from before the switch.
- Back up the archive in at least two places. Cloud storage plus a local copy is enough. Since it’s plain text, the file size stays small enough that this takes no real effort.
This approach respects the reason you started the single file in the first place, keeping your history in one readable piece, while adapting to a growing archive instead of forcing an old system to keep stretching past its comfort point.
Setting Up Your Own One-File Journal
If you want to try this method, the setup takes about five minutes and doesn’t need any special software.
- Pick a plain text format. A
.txtfile works everywhere. A.md(Markdown) file works almost everywhere too and lets you use simple headings, which makes date anchors easier to scan visually. - Decide on a consistent date format and stick to it. Whether you write
## July 12, 2026or07/12/2026, consistency is what makes search reliable later. Changing the format halfway through makes searching harder. - Choose where new entries go. Adding new entries at the bottom keeps the file in the natural order you wrote it, which is easier to read straight through. Some people prefer adding at the top so the newest entry is always visible first. Either works, just pick one and stay consistent.
- Store it somewhere that syncs automatically. A synced folder (through whatever cloud storage you already use) means the file updates across your devices without extra steps.
- Open it the same way every day. Habit matters more than tool choice here. Whether that’s a notes app on your phone or a text editor on your laptop, using the same entry point every day removes the friction that kills most journaling habits.
Common Questions About the One-File Method
Does a huge file slow down my phone or laptop? Not until it reaches a genuinely large size, usually several years of consistent writing. Plain text files are small compared to almost any other file type, so even a decade of daily entries typically stays under a few megabytes.
What if I want to add photos to some entries? You can note where a photo lives (a folder name or a short description) inside the text entry itself, rather than embedding the image. This keeps the file lightweight while still linking your writing to the memory.
Can I still use this method with a note-taking app instead of a plain text editor? Yes. Many note apps let you create a single long note and just keep adding to it. The key isn’t the software, it’s keeping everything in one continuous document instead of creating a new note for each day.
Is it harder to stay private with one file compared to separate notes? Not really. A single file can be encrypted, password protected, or stored in a private folder just as easily as separate notes, sometimes more easily since there’s only one file to secure instead of hundreds.
What happens if the file gets corrupted? This is the strongest argument for regular backups. Since everything lives in one place, protecting that one file well (two backup locations, updated regularly) matters more than it would with scattered notes.
Final Thoughts
The note-per-day habit isn’t wrong, but it isn’t automatically right either. It’s just the default that modern apps push because it fits how software gets built, not necessarily how people actually want to read their own lives later. A single growing file trades some organizational polish for something harder to get from split notes: the feeling of reading your life as one continuous piece of writing, the same way it actually happened.
If you’ve been struggling to keep a journaling habit going because starting a new note every day feels like a small but real barrier, this method removes that barrier entirely. Open the same file, write, save, close. That’s the whole system.
Have you tried keeping your journal in one continuous file, or do you prefer a fresh note for every day? I’d like to hear which one has actually worked for you long term.
