I started this exercise with a simple idea: use Microsoft OneNote as a long-term archive for my ChatGPT work.

The idea itself is excellent. OneNote has a beautifully simple mental model:

Notebook → Section → Page

That is intuitive. It is flexible. It is exactly the kind of structure that should work brilliantly for research, ideas, projects and long-running conversations.

Then I tried to actually use it.

What followed was a surprisingly entertaining tour through OneDrive, SharePoint, OneNote Desktop, OneNote Web, Web Clipper, synchronization, notebook folders, display names, cloud locations and local folders.

The underlying product is actually quite good.

The problem is that Microsoft makes you understand far too much of its underlying architecture before you can use it comfortably.

The first problem: Where does the notebook actually live?

The first surprise was that a OneNote notebook is not treated like an ordinary file that I can simply save anywhere on my PC.

I wanted the obvious option: create a notebook, choose a folder, and carry on.

Instead, modern OneNote expects the notebook to live in a cloud location such as OneDrive or SharePoint. The desktop application works with a synchronized local copy/cache rather than treating a local notebook as an independent master file.

That architecture makes sense for synchronization across devices. But the user is not thinking about architecture. The user is thinking:

“Where is my notebook?”

And Microsoft gives several answers depending on which application and screen you happen to be looking at.

The first set of problems came from the mismatch between the simple mental model and Microsoft’s actual storage model.

There was OneDrive Personal. There was SharePoint. There was a Communication Site. There were notebook folders. There were local synchronized folders. There were different-looking OneDrive interfaces.

At one point I even tried creating a notebook somewhere other than the locations OneNote offered. That triggered a OneDrive folder setup screen.

In other words, I was trying to create a notebook — and Microsoft started configuring a storage relationship.

That is the moment when a simple note-taking application starts feeling like an enterprise IT administration console.

Then came the naming problem

The next discovery was even stranger.

In OneNote Desktop, I could open Notebook Properties and change the Display name.

Great.

Except the dialog itself quietly says:

“Does not affect the actual notebook folder name.”

So the notebook appears to have a name that isn’t really its name.

Changing the display name does not rename the actual cloud notebook/folder. To change the real cloud name, you have to go to the OneDrive/SharePoint location and rename the underlying object.

This is where the product’s internal architecture leaks directly into the user interface.

The funny part: almost everything else syncs perfectly

And this is where the whole thing becomes almost comic.

I tested the individual components.

  • Section name? It syncs.
  • Section colour? It syncs.
  • Page title? It syncs.
  • Page content? It syncs.
  • Formatting? It syncs.
  • Web Clipper content? It can sync.

But the notebook display name changed in Desktop? Not the actual cloud name.

The hierarchy looks like one coherent object:

Notebook → Section → Page

But the three levels don’t behave consistently because the notebook is also a storage/container object underneath.

That distinction may make perfect sense to a Microsoft engineer.

It makes much less sense to the person taking notes.

The frustration

A good interface should hide implementation details unless the user needs them.

If I rename a section, I expect the section to be renamed everywhere.

If I rename a page, I expect the page to be renamed everywhere.

If I rename a notebook, I expect the notebook to be renamed everywhere.

The user should not have to know whether the object is stored as a OneNote entity, a SharePoint folder, a OneDrive object or something else.

That is Microsoft’s job to abstract away.

The Web Clipper: another boss fight

The Web Clipper was particularly revealing.

The goal was simple: take a useful ChatGPT conversation and save it into OneNote.

The first attempt failed with a message saying that something went wrong while saving the clip.

Then, after another attempt, it worked.

The successful result was actually excellent: the conversation was clipped into a OneNote page, the source ChatGPT link was preserved, and the page appeared inside the selected notebook section.

That proved the concept.

ChatGPT → Web Clipper → OneNote notebook → section → page

Once it worked, it was exactly what I wanted.

The problem was getting there.

The solution: stop fighting the architecture

Eventually the solution became clear.

Don’t fight the cloud-first architecture. Use it deliberately.

The clean model is:

OneDrive / SharePoint → Notebook → Sections → Pages

Let OneNote own the notebook structure.

Let OneDrive/SharePoint own the cloud storage and synchronization.

Use OneNote Desktop for serious editing.

Use OneNote Web when convenient.

Use Web Clipper to capture web material directly into the appropriate section.

And most importantly: don’t treat the notebook name like a normal page or section property. If the actual cloud name needs changing, rename the cloud object at its storage location.

A practical OneNote system for ChatGPT

For my own use, the obvious structure is a dedicated ChatGPT archive notebook.

ChatGPT Archive
│
├── AI & Technology
├── Trading & Markets
├── Website & WordPress
├── Infographics
├── Mathematics
└── Miscellaneous

Each important ChatGPT conversation can become a page.

This is where OneNote’s underlying design suddenly becomes very powerful. A long-running conversation does not have to remain buried inside chat history. It can become a durable research page inside a structured knowledge system.

That is a genuinely good idea.

What Microsoft got right

It is easy to spend an entire article complaining about Microsoft. But that would miss the interesting part.

OneNote’s core information architecture is good.

Notebook → Section → Page is simple and intuitive.

Sections can be renamed and coloured. Pages can be organized. Content can synchronize between desktop and web. Web Clipper can turn web material into pages. The cloud model makes the notebook available across devices.

The pieces are there.

The frustration comes from the boundaries between products and layers: OneNote + OneDrive + SharePoint.

The user sees one notebook.

Microsoft sees a notebook sitting inside a storage system sitting inside a service architecture.

The user should not have to see the second version.

The real lesson in product design

This whole experiment produced a broader lesson.

Complex software does not become simple merely because its individual components are well engineered.

A product is experienced as a whole.

OneNote may have an excellent synchronization engine. OneDrive may have a sophisticated storage model. SharePoint may be extremely powerful. Web Clipper may be useful.

But if the user has to understand all three systems just to rename a notebook, the integration is failing at the experience level.

The best products hide complexity.

They don’t make the user become an accidental systems administrator.

Conclusion: How Not to Design a Product

My verdict is therefore slightly unfair but affectionate:

OneNote itself is actually quite good.

The Notebook → Section → Page model is excellent.

The cloud synchronization model is sensible.

The Web Clipper can be extremely useful.

But the surrounding experience sometimes feels like this:

User: “I want to rename my notebook.”

Microsoft: “Excellent. First, please understand OneDrive, SharePoint, notebook containers, cloud identities, local synchronization and the difference between a display name and an actual folder name.”

That is not how a note-taking application should feel.

A good product should make the powerful architecture disappear.

The user should see:

Notebook → Section → Page

Everything else should just work.

And if I ever write a book called “How to Use MS OneNote,” the first chapter may simply be titled:

“How I Accidentally Became a SharePoint Administrator While Trying to Take Notes.”

How AI Is Making the Lazy Brain More Productive