Notion starter kit: Make it easy to reverse mistakes
The more reversible our mistakes, the less we fear making them.
Product designers are a forgiving folk.
Every one of us has a story to tell about how we meticulously planned out a feature, only to despair when we watched our users poke and prod our product in ways we never considered possible.
To see our thoughtfully crafted flows fail as they’re pushed to their limits can be a humiliating humbling experience.
But we don’t take it personally.
Because we’ve trained ourselves to forgive our users.
Forgiveness is an essential skill for product design. It’s a skill we actively embody by building it into our apps. It’s a trait that all of our favourite products possess.
Imagine, for example, an unforgiving version of your favourite note-taking app that doesn’t offer an undo button. Or an uncompromising streaming platform that forces us to finish watching every movie we dare to start.
Everybody makes mistakes. And it’s a designer’s job to anticipate those mistakes and make sure their app forgives them.
So what does it mean for an app to be forgiving? What forgiving features does Notion offer? And how can we design even more forgiveness into our Notion pages?
There are a few ways an app can featurize forgiveness:
Predictive forgiveness: Features that let people explore potential futures
Preventative forgiveness: Features to stop mistakes before they happen
Reversible forgiveness: Features that let people to rewind time
The goal of this post is to walk through the ways Notion has built in forgiveness and how we can create more forgiving pages ourselves.
Predictive forgiveness: Looking ahead
Predictive forgiveness provides users a peek into a possible future they can expect to have. It models their expectations and projects them into a safe environment where they can experiment freely.
Consider, for example, websites that sell eyeglasses. Many now let us test how frames would look on our face using augmented reality. We’re able to avoid buying an unflattering pair by experimenting with varying versions of our future.
When designing predictive forgiveness into our Notion space, it helps to ask:
What version of this feature or page do I hope to end up with?
How can I get a taste of that version before I commit?
Here’s how I’ve learned to incorporate it into my own environment:
Duplicate playgrounds: Clone your workspace
When I want to make major architectural updates to existing systems, I duplicate them and make all my changes in the fresh copy first.
While I’ll also discuss ways to revert pages to previous formats, I find that working on draft branches from the start makes me feel safer and, as a result, more ambitious with experimentation.
Things I tend to duplicate before committing changes: pages, databases, database properties, and views.
Starter playgrounds: Test before committing
Sometimes when I want to introduce more complex systems in my spaces I’ll also create a draft page for experimentation.
Honestly, I was more prone to doing this before I had access to Notion AI, so I tend to dive in head first these days. But I found this particularly handy when I wanted to create systems of interconnected databases. There were several times when starting small with a few entries in a couple databases helped me course correct when my original plans weren’t actually feasible.
In practice: How to create duplicate playgrounds
1. Duplicate the thing you’re about to “operate” on:
- For a page: open ••• (top right) → Duplicate.
- For a database: open the database as a full page → ••• → Duplicate.
2. Rename the copy so you can’t confuse it (ex. `Playground — Life Blocks (copy)`), and add an obvious emoji like 🧪.
3. In the duplicate, perform the risky change first:
- new views and filters
- new relations
- property edits (especially formulas)
4. Stress test the clone:
- add 5–10 dummy entries
- try the edge cases you know you’ll hit
5. Only after it behaves the way you want, repeat the change in the “real” system.
Visualize: Start with a written or visual plan
One of my biggest Notion vices is building without thinking things through. I’ll get excited about a new page or feature and start creating right away.
But I iterate far more on those impulsive pages than on ones where I’ve written out a plan detailing exactly what I hope to achieve and how I’ll design it.
Preventative forgiveness: Protecting the present
When it comes to preventative forgiveness, the goal is to catch mistakes in and around the moment of them happening and to guide users toward a better course of action.
When done well, using an app should feel like bowling with gutter guards, a streamlined flow with protections in place to prevent unintentionally veering away from our goal.
Questions to consider when designing our systems:
What are the weakest links in this process?
What is my primary goal and what guardrails should be in place to keep me focused?
How can I course correct myself?
Here’s how I’ve gone about preventing mistakes in my own space:
Lay of the land: Understand safe vs. risky actions
For a new user, it’s easy to freeze up when all actions feel equally risky. So it helps to get a lay of the land and identify which actions are safe, risky, and downright dangerous.
In Notion, most actions are safe and easily reversible, but there have been some hidden landmines that’ve surprised me in the past.
Here’s a quick roundup:
Mostly safe, but can get annoying (reversible, but you can lose time)
Editing view filters/sorts/groupings: Reversible by undoing and using version histories.
Duplicating databases: I’ve often found myself confused about what exactly happens when I duplicate a database. Are the updates linked to the original or is every page completely separate?
Here’s what I’ve learned.
When duplicating a database, Notion makes a new database (with its own schema + views) and duplicates of all of the existing pages.
The original database and its pages stay untouched.
How to do it safely: Open the database as a full page → ••• → Duplicate → immediately rename the copy something loud like
🧪 Playground — Payments DB (copy).Sanity check (so you don’t mistake a linked view for a clone): In the copy, open any row/page → look at the page breadcrumb. If it points to your new “Playground” database, you’re editing the clone. If it points to the original database, you’re in a linked view.
Rule of thumb: Duplicate when you want a branch you can break. Create a linked view when you want to view or edit the same data in multiple places.
Risky
Moving pages between databases: Data may not map cleanly to the new schema (especially when you have Select properties with a lot of tags). You can end up with empty properties or lost structure.
Editing formulas: Can accidentally break dashboards and views that rely on that computed value. Reversible, but debugging can be a time-sink.
Rebuilding relations: Removing relation values is easy. Reconstructing it can be hard.
Offline mode: My panic attack
As of writing this, offline mode is a pretty new feature for Notion, and my first experience with it caught me off guard.
I was on a five-hour train ride home to Toronto from a work trip to Montreal. I forgot to connect to my phone’s hotspot, and I was three hours into writing a Substack post.
I navigated away from my draft to refer to another page in Notion. And when I returned, my heart dropped. The page was virtually blank, and the top corner read “Last edited 3 hours ago.”
It’s been a while since I’ve referred to the stages of grief, but based on my experience, I’m guessing it’s something like paralysis, denial, anger, and agonizing hopelessness.
Out of desperate optimism, I quickly linked my laptop to my phone’s hotspot, hoping all my work would reappear. Instead, I stared in horror at the snowy abyss of my blank page.
Until I saw a flash on my screen.
That “Last edited 3 hours ago” changed to “Last edited 2 hours and 40 minutes ago.”
After that, every several seconds, remnants of my work popped onto the screen as Notion’s lag slowly caught up to my version of reality.
It was a big lesson learned: Offline Notion is like a turtle. It’s got a shell to protect us and keep our work safe, but it operates at its own pace, so don’t panic if it’s not sprinting to catch up.
Reversible forgiveness: Looking back
Imagine being able to rewind time. Whenever you blundered or erred, you could simply turn back the clock and undo what you did.
It’s a superpower many of us daydream about and it’s also the reality that a well-designed app offers: thoughtful ways of preserving and restoring histories we might want to return to.
Whether it’s undo buttons or version histories, reversible forgiveness is already provided all throughout Notion, but we can also secure our work with some additional backtracking strategies.
Here are a few of my favourite ways to turn back time in Notion:
Workspace backup: Clone the entire workspace
This one is the equivalent of having a backup bunker somewhere in case of an apocalypse and it brings me so much peace of mind.
Every few months, I download my entire Notion workspace. That way, if something catastrophic happens to Notion or its servers, I have a copy of all of my information on my own device to return to.
In practice: How to backup your workspace
Goal: export a copy of your entire workspace so you have an offline “restore point.”
1. In Notion, open **Settings**:
- Desktop: Notion (top left) → Settings.
- Web: sidebar → Settings.
2. Go to **Export content** (or “Export all workspace content,” depending on your plan/UI).
3. Choose export format:
- **Markdown & CSV** = easiest to read/migrate later.
- **HTML** = easiest to browse like a website.
4. Choose scope:
- Export **Entire workspace** (not just “Current page”).
- If you see toggles for “Include subpages” and “Include databases,” turn them on.
5. Click **Export**, then wait for the download link/file.
6. Save the export somewhere deliberate:
- a folder like `Notion Backups/YYYY-MM`.
- optionally also a cloud drive.
7. (Optional but smart) Put a recurring reminder on your calendar: monthly or quarterly.
Note: this backup won’t preserve every Notion-native behavior (like live databases exactly as-is), but it gives you a durable archive of your content.
Version history: Rewind time
I’ve lost count of how many times I’ve stared blankly at a page I’d just been working on, wondering how I messed it up so badly. That’s why discovering Notion’s version history has been a godsend.
In practice: How to access your version history
1. Open the page you’re worried about.
2. Open the page menu (••• in the top right).
3. Click Version history.
4. Click through earlier snapshots until you find the “before.”
5. Restore that version (or copy what you need back into the current version).
Archive instead of delete: Try soft deletion
At the bottom of many of my pages, you’ll find a toggle with a skull icon labeled “Archive.” Inside, you might discover old database versions with hundreds of entries or previous page iterations I’ve hoarded.
While Notion offers version histories, they don’t last forever for most of us.
Version history retention based on plan
- Free: 7 days
- Plus: 30 days
- Business: 90 days
- Enterprise: Unlimited
So if a page might be useful later but doesn’t fit my current system, I archive it.
Similarly, when I want to test a big update to any of my databases, I’ll create a new one and archive the old version just in case the new one doesn’t work out.
That’s it for my learnings about protecting ourselves from those nefarious Notion missteps, but stay tuned for next time when I explore my favourite ways to learn about Notion and its tools without feeling overwhelmed.
See you then! 👋