How We Turned Notion Into the Operating Layer for Content and Ads

Most teams don’t have a content problem. They have a workflow problem.

For a long time, our content and ad production looked modern from the outside and ridiculous from the inside. Ideas lived in one place. Feedback lived somewhere else. Assets arrived in zip files. Copy got rewritten in chat threads. Approvals disappeared into Slack. Final versions got lost between folders, social schedulers, ad managers, and random messages that started with “just checking if this is the latest one.”

The painful part is that none of this looked broken enough to justify a rebuild. It was just broken enough to slow everything down. A little friction at every step. A little ambiguity around ownership. A little delay each time someone had to ask where the brief was, which version was approved, or whether the ad that was performing was actually linked to the creative we thought we had shipped.

Then we rebuilt the system from first principles.

Not around another dashboard. Not around another AI wrapper. Not around another place to dump files. We rebuilt it around a simple idea: Notion should become the operating layer for content production and ad publishing, and AI should act inside that system instead of outside of it.

The problem was never a lack of tools

The modern marketing stack is full of specialized software. That sounds efficient until you try to run a fast-moving content machine with it. The team uses one tool for research, another for planning, another for writing, another for design, another for internal review, another for client approval, another for scheduling, and another for publishing ads. Every handoff creates latency. Every tool switch creates context loss. Every missing link between those tools creates manual work that nobody planned for.

That was the real issue. We were not suffering from a lack of capability. We were suffering from fragmentation. The system was asking humans to act like middleware.

Once you see that clearly, the role of AI changes. AI is not just there to generate a headline or produce a visual faster. Its real value is in removing the glue work between steps, preserving context, and helping the whole pipeline behave like a system instead of a pile of disconnected tasks.

Why we chose Notion as the operating layer

Notion was already the obvious center of gravity. It can hold structured databases, unstructured thinking, linked records, workflows, approvals, and documentation in the same environment. That matters more than most people realize. When strategy, production, and operations live in separate tools, the cost is not just inconvenience. The cost is that decisions stop carrying forward.

We wanted one place where a piece of content could begin as a research insight, become a brief, turn into creative production, move through approval, and end up published as an ad or a post. We wanted every step to inherit context from the previous one. We wanted collaborators to work from the same source of truth instead of rebuilding understanding every time they touched a task.

So instead of treating Notion like a passive repository, we started treating it like an operational database for content. That shift sounds subtle, but it changes everything. Once the system is structured correctly, agents can read it, enrich it, update it, and move work forward with much less human babysitting.

The big shift: from tools everywhere to agents inside the workflow

A lot of teams are currently making the same mistake with AI that they made with SaaS. They keep adding tools. A writing assistant here. A design generator there. A prompt tucked into another tab. The result is impressive demos and mediocre operations.

What started working for us was the opposite approach. We stopped asking, “Which AI tool should do this task?” and started asking, “What should the system do next?” That is a very different question.

In practice, that means agents operate against a structured pipeline. One step can pull competitor signals and turn them into usable angles. Another can generate creative directions from those angles. Another can prepare variants for review. Another can package approved assets and copy for publishing. Another can push the final payload to the right channel. The magic is not in any single generation step. The magic is in continuity.

This is where MCP became important for us. It gave collaborators and tools a cleaner way to connect to the same operational context. Instead of sending screenshots, forwarding docs, or manually translating intent between systems, we could make context portable. When a collaborator joins the workflow, they plug into the same source of truth. When an agent acts, it acts with the same context. That is what makes the whole thing feel less like automation theater and more like an actual operating model.

Rebuilding the creative pipeline around structured inputs

The most powerful part of the rebuild was not actually the generation layer. It was upstream from that. We became much stricter about the structure of inputs.

If competitor research sits in screenshots, if positioning lives in someone’s head, if the brief exists as a loose paragraph in chat, the output will always be inconsistent. So we pushed the opposite direction. Research became structured. Angles became structured. Creative hypotheses became structured. Approval states became structured. Distribution targets became structured.

That created a very different production environment. Instead of starting from a blank page every time, the system starts with context that is already usable. By the time AI touches the workflow, it is no longer guessing what matters. It is operating on explicit inputs with clear intent.

This is especially important in ads. Creative performance is increasingly the main lever, especially as platforms like Meta automate more of the targeting and bidding layer. If creative is the lever, then the speed and quality of creative iteration becomes a real strategic advantage. You cannot get that advantage if every new concept requires manually reassembling context from six different places.

What we learned from rebuilding a high-spend Meta campaign

The most useful stress test for this system was a high-spend Meta campaign that forced us to confront how fragile the old process really was. When volume goes up, weak workflows stop being annoying and start becoming expensive.

We saw the usual symptoms. Too many handoffs. Too much ambiguity. Assets moving without proper tracking. Review cycles that looked active but were mostly waiting. A system full of talented people still producing avoidable delays because the workflow itself had no spine.

The fix was not heroic effort. It was redesign. We reduced the number of places where work could stall. We clarified state transitions. We made approval visible. We made outputs easier to package for the next step. And we made sure every asset, message, and decision could be traced back to a structured object in the pipeline.

The approval bottleneck was bigger than we thought

If you ask most teams where content production slows down, they will usually point to ideation or execution. In our case, the bigger problem was approval. Not because people were incompetent or slow, but because the system made approval heavier than it needed to be.

Feedback was fragmented. Ownership was blurry. People were reviewing artifacts without the full context that produced them. Sometimes the asset was ready but the copy was not. Sometimes the copy was approved but the final format was still unclear. Sometimes everyone thought someone else had already signed off.

Once approval became a first-class part of the workflow instead of an afterthought, things moved very differently. We gave approval a defined place in the pipeline, a defined state, and a cleaner path to resolution. That removed an absurd amount of dead time.

The result was dramatic. Turnaround went from eight days to forty-eight hours. Not because people suddenly worked harder, but because the system stopped leaking time at every edge.

Closing the loop from research to design to publishing

The part I am most excited about is not that we can generate ads faster. It is that we can finally close the loop. Competitor research can inform briefs directly. Briefs can generate creative directions. Approved concepts can turn into production-ready assets. Final assets can move into publishing without another manual rebuild. Then performance data can come back and improve the next round of ideas.

That loop is what most teams are missing. They have tools for each stage, but they do not have continuity across stages. So every campaign starts half from scratch. Every lesson gets partially lost. Every win is harder to operationalize than it should be.

When the loop closes, content starts compounding. The system remembers what worked. The structure makes reuse easier. The agents make movement cheaper. The team spends less time coordinating and more time making good decisions.

What this changed for how I think about Notis

This rebuild clarified something I had been feeling for a while. The future is not a collection of AI features scattered across software. The future is software that can think and act inside the operational reality of a business.

That is the opportunity I see for Notis. Not another assistant living in a sidebar. Not another chatbot waiting for instructions. A system that sits where the work already happens, understands the structure of that work, and helps move it forward from one state to the next.

For content and ads, that means becoming the layer that connects research, planning, generation, review, approval, and publishing. For other workflows, it will mean something slightly different. But the principle stays the same. The winning products will not just generate. They will orchestrate.

The real lesson

If there is one lesson from all of this, it is that speed does not come from doing each task faster in isolation. Speed comes from designing a system where context survives and work keeps moving.

That is what we were actually building. Not a faster content team. A better operating model.

And once you have that, AI stops feeling like a party trick. It starts feeling like infrastructure.