Can you guess what it actually is?

It’s capacity.
It’s overwhelm.

Sometimes students of our program Notion Mastery leave only to return later, and 99% of the time it’s because “life got in the way.” We even added a workshop leading into our program to help people improve their capacity planning skills. It’s that fundamental.

And it’s often not “busy work” getting in the way. No, not “I’ve got too much on my plate.” It’s things like “family illness,” it’s “we’re absolutely terrified by the state of the world right now and unable to focus,” it’s “I just can’t afford this right now,” it’s “I just lost my job.”

Of course, I do find that overwhelm can often be a natural byproduct of our experience with complicated systems like Notion. Education and practice can help us navigate complicated environments, but complex ones can cost us dearly energetically. Notion can tip into the complex at times, because it changes rapidly from both a functional and visual perspective, not to mention multi-player modes and the introduction of so-called “Agentic AI”.

For this reason it can be a lot to learn and continually adapt to. Even as one of the world’s top “Notion understanders,” I’m continuously frustrated by what I call the wash of continuous adaptation (that anxious feeling, like you’re in a giant celestial washing machine).

Indeed, complex environments are difficult to navigate. A good way to operate in them is from an action-first mindset. It’s quite difficult to just “design it right” when we don’t have an understanding of the component parts nailed down quite yet or we’re not sure what our individual needs are. Said differently: in complex scenarios (like learning Notion while also developing your own workflow habits) where there are no obvious next steps, there are no true best practices here besides “Try something. What happens?”

Many folks come to our program seeking the System that helps them do Everything (“How do I take Marie’s, August’s, Thomas’s, and Tiago’s systems and make it mine?”). There’s no solve for that level of complexity besides diving into the unknown and getting uncomfortable. And discomfort can be…overwhelming.

My advice on not getting overwhelmed?

Slow. Down. Pause. Deep breath. Take your time. Small actions.

“Wow, amazing insight, Ben—just ,” you might be saying, “why didn’t I think of that?!” Well, to be frank, you didn’t really. You don’t. And I don’t either. We always tend to think we have more capacity than we do. We think we can grit our teeth and push through overwhelm and burnout, but the truth is, that doesn’t work.

So let’s talk about what might.

How might you learn Notion and protect your energies?

Challenge yourself with one small discovery each week and build something fun for yourself that helps you navigate one micro-aspect of your life. Resist the urge (demand) to “solve for productive” and the attempt to emulate creators and educators who’ve been building productivity systems for decades. The macro comes with time and experience; expose yourself to a little bit more complexity when you feel you have the capacity to do so. And if that doesn’t come, that’s okay:

This is your productivity journey; compare it to no others’.

Complexity can be invigorating in this way. You might even grow to enjoy a bit of chaos in time. But, by goddess, give yourself a small amount of the grace you extend to others on this journey!

Build something in Notion like an observability system for your energy. Rather than tracking tasks and habits, start with a journal/log noting what happened throughout your day and log within it the circumstances of your experience.

Imagine you’re not trying to accomplish anything with this system beyond observation.

Start from experience, noticing what comes up when you do. Were you able to get the most important thing addressed today? Great, celebrate it in your Notion journal. Flag that day as a highlight with a checkbox property. Go back and review those highlights on your less energetic days—what was occurring that day that might indicate how that burst of energy came to be? Could you recreate the conditions? Was it the same environment? Same people? What changed and how did you change to meet the occurrence?

Did you not address the most important thing today? Also great! Celebrate that too and lean into the discovery in the discomfort of failure. What got in the way? What wasn’t accounted for? How might you keep it in mind in the future? Do you need to track it in Notion or might there be a real-world environmental change that might prompt you to perform that action more effectively?

This is the meta-work; learning about yourself.

Like Marie with her “Curiosity Engine”, how might you become a documentarian of your life and routines rather than a self-abusive task-manager? Celebrate yourself more; track joy and enjoyment; add views that return those moments to you. Perhaps a shared database so you and your partner/family can really enjoy these moments together.

Marie and I have a shared highlights database we add a daily highlight to. At the end of the year, spending time reflecting on 365×2 highlights together is magical and motivating. So many forgotten moments recalled. So much joy surfaced.

Surfacing memories and moments as a practice.

If you want a habit to keep up, develop a review habit. Add startup and shutdown routines to your journal. Document your rituals. Do you have an idea what an “ideal day” looks like for you? Write it down.

Track gratitude: Who helped you today? Who did you help today?

Build on the review practice. Add a new database for weekly reviews. After 4 weeks of this practice, perhaps add a new database for monthly reviews. Sit with this for 3–6 months adding nothing else. How can you leverage Notion’s block-based design to add variance and personal interest to your pages?

Try something new every day. It’s not important that it solves a need, just that you observe the impact to your operation.

At 6–12 months, build a dashboard and use linked views of your data sources to create an annual review. Might you publish it? Phew, that’s quite vulnerable. But what might you discover in the rawness of your less observable identities?

This is how you sit with overwhelm: by sitting with the problem for a long time. Stewing in it. Not desiring going any further than observation.

Can you resist the pull of progress and focus on betterment instead?

There’s a powerful religion in observance of progress, disconnected from nature. Progress is fickle and impatient, however; the bearers of its standards addicts. It must be fed and is insatiable—its gaping maw the event horizon of endless responsibility known as productivity.

But progress can be resisted. You can focus on building systems that help you stay in the mode of being rather than doing. You can build the utilities and systems that better you and keep you grounded in your experience, avoiding the acceleration and the whiplash of pacing technical progress.

Asking ourselves: who does this progress serve?

The post How to Approach Learning Notion with Minimal Overwhelm appeared first on Notion Mastery.

Move API

2026 has been a great year for additions to the public Notion API. In October we got the ability to apply and update templates via the API, and to close out the year it’s now possible to move pages into other pages and data sources via the API.

Note: if you just want the example code, check the “move-page” example folder in my Notion API examples repository.

Use-cases

So what can you do with this? In short, you can move a page into a different page if you have the ID of the page and the ID of the target. The target ID can either be the ID of a page or the ID of a data source. 

Use-case wise, I’m seeing utilities like the following examples:

• You might move a series of pages that do not have a database parent into the data source in the database.
• Perhaps you captured content into the wrong database and want to “reparent” them into a different database.
• Maybe you want to archive a series of pages in a data source and move them into a backup data source that has the same schema. 
• You might move pages into another page, organizing them in one location.

Moving a page into a page

First of all, we need the IDs of the page to move and the target page. Then we call the asychronous move function on the pages endpoint.

				
					const page_id = '2af1c1cce3f3802985bdecfa26194f94';
const target_page_id = '2ae1c1cce3f3815a8140ce2cac1a27b8';

await notion.pages.move({
    page_id: page_id,
    parent: {
      type: 'page_id',
      page_id: target_page_id,
    },
});
				
			

notion.pages.move returns a object representing the page that was moved.

Moving a page into a data source

Moving a page into a data source is a very similar operation, but we use data_source_id instead of page_id:

				
					const page_id = '2af1c1cce3f3802985bdecfa26194f94';
const target_data_source_id = '2ae1c1cce3f3815a8140ce2cac1a27b8';

await notion.pages.move({
    page_id: page_id,
    parent: {
      type: 'data_source_id',
      data_source_id: target_data_source_id,
    },
});
				
			

Can I use this with my automation platform?

So how can you use this with Make, Zapier etc.?

Much like the template application APIs, this is dependent on the platforms adding support for the move API. At the time of this writing, no platforms are supporting this endpoint directly. So you’ll have to use something different.

For example, when the endpoint had been added to Notion’s public API, but not to the JavaScript SDK yet, I used Axios to make a POST request instead like so:

				
					const response = await notionAPI.post(`/pages/${page_id}/move`, {
    parent: {
      type: 'page_id',
      page_id: target_page_id,
    },
  });
				
			

But how do I do this with Make or Zapier?

• Zapier – use the Webhooks by Zapier action to send a POST request to the Notion API.
• Make – use the HTTP – Make a Request module or the Notion – Make an API Call module to send a POST request to the Notion API

In both cases, you’re sending a request to https://api.notion.com/v1/pages/{PAGE_TO_MOVE_ID}/move, where {PAGE_TO_MOVE_ID} is replaced by the ID of the page you are moving. You also need to send the parent in the body of the request as a JSON object.

Locally, again I used Axios to create my own simple wrapper to the Notion API in case the JavaScript SDK doesn’t support a specific endpoint (which you can see I used above imported as notionAPI). 

				
					const { default: axios } = require('axios');
const dotenv = require('dotenv');
dotenv.config();

const NOTION_VERSION = '2025-09-03';

const NOTION_HEADERS = {
  Authorization: `Bearer ${process.env.NOTION_API_TOKEN}`,
  'Notion-Version': NOTION_VERSION,
};

const JSON_HEADERS = {
  ...NOTION_HEADERS,
  Accept: 'application/json',
  'Content-Type': 'application/json',
};

const notionAPI = axios.create({
  baseURL: 'https://api.notion.com/v1',
  headers: NOTION_HEADERS,
});

module.exports = notionAPI;

				
			

That’s nice for me the hacker, but what if you don’t have all this code stuff set up and ready to use locally…

Moving pages with Make

In Make, I added a Notion module making sure the account I am using has access to the pages/data sources I need it to have access to.

I then select the Make an API Call action of the Notion module to be able to make a manual API call with the Notion API:

1. We set the URL to /v1/pages/{{var.input.page_id}}/move. You must define page_id somewhere. It could come from another module, for example. In my scenario I set the scenario to run On demand and added page_id as an input parameter supplied when the scenario is run. In my screenshot it shows as page_id but it is actually the value {{var.input.page_id}} behind that name (you can see these actual values if you copy and paste text to/from Make scenarios).
2. Set the Notion version to “2025-09-03”. This is the version of the Notion API—a date—not the version of the Notion client.
3. Make sure the Method is set to “POST”.
4. Finally we supply the Body of the request as a JSON object. See below for the value. Again, I am using target_data_source_id from the scenario’s inputs.

				
					{ 
    "parent": { 
        "type": "data_source_id",
        "data_source_id": "{{var.input.target_data_source_id}}" 
    }
}
				
			

When this scenario runs it’ll take my manually supplied page_id and target_data_source_id input parameters and inject them into the URL and Body parameters of the request and complete the POST request to Notion.

What are you building?

What does this addition to the API unlock for you? Feel free to let me know by replying to me on BlueSky. Give me a follow while you’re there!

The post Moving Notion pages with the API appeared first on Notion Mastery.

				
					  const { data_sources: dataSources } = await notion.databases.retrieve({
    database_id: '1e7abab87ee8457799c1155cf69d502a',
  });

  const dataSource = await notion.dataSources.retrieve({
    data_source_id: dataSources.at(0).id,
  });

  const { templates } = await notion.dataSources.listTemplates({
    data_source_id: dataSource.id,
  });
				
			

				
					[
  {
    "id": "e8007a4a-9a02-45c5-bb87-544ff7a6e8b3",
    "name": "Untitled",
    "is_default": true
  },
  {
    "id": "1861c1cc-e3f3-80bf-8823-f701d4e7a2c1",
    "name": "Album",
    "is_default": false
  },
  {
    "id": "28b1c1cc-e3f3-80a3-9327-c9d8a176a4e8",
    "name": "with linked view",
    "is_default": false
  }
]
				
			

				
					 const params = {
    parent: {
      type: 'data_source_id',
      data_source_id: dataSource.id,
    },
    properties: {
      Name: {
        title: [
          {
            text: {
              content: 'Example page',
            },
          },
        ],
      },
    },
    template: {
        type: 'template_id',
        template_id: templates.at(0).id,
    },
  };

  const page = await notion.pages.create(params);
				
			

				
					  const params = {
    page_id: '28e1c1cce3f3801fb861f1cf847a861a',
    template: { type: 'default' },
    erase_content: true
  };

  const page = await notion.pages.update(params);
				
			

The post Creating Notion pages from a template with the API appeared first on Notion Mastery.

I’ve been teaching productivity and workflow design for over five years, and there’s a pattern I see repeatedly: bright, motivated people cycling through system after system, searching for the one that will finally “work” for them.

PARA. GTD. Ultimate Brain. PPV. BASB. The list goes on.

Each new framework promises to be the solution to helping you become the most effective version of yourself. Each creator presents their method as revolutionary, but the truth is that they’re all mostly teaching the same fundamental behaviors, just wrapped in different terminology.

What Is a “System” Anyway?

Before we dive deeper, let’s clarify what we’re actually talking about when we say “productivity system.”

A system is simply a set of interconnected processes that work together to produce a desired outcome. In productivity terms, it’s how you consistently:

• Capture and organize information
• Make decisions about what to work on
• Track progress toward your goals
• Reflect on and improve your approach

Think of it like a recipe. The “system” isn’t the specific ingredients (your apps, tools, or templates) – it’s the method: the steps you follow, the timing, the way different elements combine to create the end result.

Most people get caught up in the ingredients (Should I use Notion or Obsidian? What’s the perfect template?) when they should be focusing on the method (How do I consistently review my goals? What helps me decide what to work on next?).

This is why you can implement the same fundamental system principles across completely different tools, and why switching tools rarely solves productivity problems.

PARA and GTD: Methodologies, Not Complete Systems

PARA is a knowledge organization methodology – it’s a framework for categorizing information (Projects, Areas, Resources, Archive). It’s one component that could be part of a larger system.

GTD is a task management methodology – it’s a framework for capturing and processing actions (capture, clarify, organize, reflect, engage). Again, one component of a larger system.

Neither PARA nor GTD is a complete system by itself. They’re methodologies – systematic approaches to specific aspects of work.

The Core Behaviors That Actually Matter

Beneath every productivity guru’s branded framework, you’ll find these same essential practices:

Capture everything in a trusted system – Whether it’s David Allen’s “inbox,” Tiago Forte’s “PARA,” or any other method, they all start with getting thoughts out of your head and into a reliable external system.

Organize by actionability – Some call them “projects,” others “pillars” or “areas.” The names change, but the principle remains: group related work together in ways that help you take action.

Regular review cycles – Weekly reviews, daily planning, quarterly reflections. Every system emphasizes stepping back to assess and adjust.

Connect ideas and information – Building a “second brain,” creating “knowledge vaults,” or maintaining “reference systems.” All paths lead to the same destination: making your accumulated knowledge useful.

Goal alignment – Whether it’s OKRs, life areas, or values-based planning, every system includes some way to ensure your daily actions connect to bigger intentions.

The Pattern Recognition Test

Here’s a perfect example of how this works in practice. Recently, a student asked about implementing Tony Robbins’ RPM (Rapid Planning Method) system in Notion. I wasn’t familiar with the system but I could predict what the core components would be.

The marketing describes planning for months, weeks, and days using “5 Master Steps” to achieve maximum results. It mentions a journal for exploring ideas, developing habits, and documenting your life.

Sound familiar? Let’s decode this:

• Monthly/weekly/daily planning = Time-based organization
• Results focus = Goal-outcome alignment
• Ideas capture = Trusted collection system
• Habit development = Recurring practice tracking
• Journaling = Reflection and review cycles

In implementation terms, this translates to the exact same database structure you’d build for any productivity system:

• Goals database
• Projects/Areas database
• Tasks/Actions database
• Habits/Practices tracker
• Daily/Weekly/Monthly journal entries
• Ideas/Notes collection

The “revolutionary” RPM system uses the identical building blocks as GTD, PARA, Ultimate Brain, and dozens of other methods. Only the labels and specific prompts change.

Why System-Hopping Keeps You Stuck

The search for the “ultimate” system reveals a fundamental misunderstanding about how productivity actually works. I see this mindset constantly:

“I have Thomas Frank’s Ultimate Brain course but I feel it’s lacking quite a lot. I’ve recently decided to use August PPV method. Would I be able to modify to fit both methods? Should I build it through August’s method first than adapt it?”

This question (from a real student) highlights the core issue: the belief that there’s a perfect, ready-made system waiting to be discovered.

There’s also the element of FOMO; when a large mass of people are using a popular system, it can be easy to believe you’re missing some key insight if you’re using a different system.

My hot take is that most people system-hop because they’re seeking to avoid the discomfort that inevitably comes from actually engaging with a productivity system. Implementing any system requires confronting chaos and resistance—and switching systems offers temporary relief from that reality.

It’s normal for tasks to linger on our list longer than they should.
It’s normal to skip doing a weekly review because we’re too tired.
It’s normal for things to feel messy, or information to feel chaotic.

It doesn’t necessarily mean the system is broken; it just means you’re a human doing your best to stay organized in an increasingly complex landscape. Real systems are a little messy.

Here’s what I’ve learned after working with hundreds of students: the most effective systems are co-created, not adopted wholesale.

The Implementation Problem

Most people struggle with ready-made systems because:

• The system isn’t flexible enough for their unique circumstances
• They don’t understand their own workflows well enough to customize effectively
• They haven’t developed the meta-skill of system design and iteration
• They’re seeking external validation rather than trusting their own experience

What Actually Works: Principles Over Prescriptions

When I first launched the Notion Mastery program, I gave students a fully built system with all the databases, relations, and formulas ready to use. The result? Most students felt overwhelmed because they hadn’t helped create it. They didn’t understand how things connected or why the system was built that way. Their capture habits weren’t established. Their workflows hadn’t been established. They didn’t have review practices established. Giving someone a set of components without factoring in the principles and practices that support it was setting them up to fail.

Ready-made systems are typically designed by one person to achieve specific outcomes—and inevitably carry that creator’s biases, perspectives, needs, and experiences.

Someone who is self-employed has different needs than a person with traditional employment. A young entrepreneur’s workflow differs significantly from that of a parent with a part-time job. The idea that a single “productivity system” could work for everyone is simply unrealistic.

If I design a system requiring daily journal entries and give it to someone who hasn’t developed that habit, I’m setting them up to feel like a failure when they inevitably struggle to stick to the system.

Now I don’t teach how to use “my system,” I teach how to use systems thinking to build your own. Instead of giving you “ready made system,” I provide a set of adaptable components, and teach you how to:

• Understand your own workflows and friction points
• Build custom solutions using provided components as a jumping off point
• Iterate based on feedback and changing needs
• Create information flows between different areas
• Design systems that grow with you
• Integrate a variety of methodologies into your own system
• Design for your specific contexts, not generic “best practices”

At the end of the day, the implementation of a system is really about how you choose to visualize the components, engage in the workflows, and how you design for your own desired behaviours.

The Universal Building Blocks

When you strip away the marketing and branding, every productivity system teaches you to build the same core components:

• Define your goals (however you want to categorize them)
• Create a simple daily journal (for reflection and planning)
• Build a habit tracker (for consistency in key behaviors)
• Capture notes and ideas (in a searchable, organized way)
• Develop review processes (daily, weekly, monthly, quarterly)
• Design planning workflows (that connect daily actions to bigger goals)

Whether you call it RPM, PARA, GTD, or something you invented yourself, you’re building the same functional components. The difference is in the specific prompts, review questions, and organizational preferences that work for your brain and your life.

The Neurodivergent Reality

As someone with ADHD, I’ve learned that most “systems” simply don’t work for me out of the box. My brain doesn’t fit neatly into other people’s organizational schemes. And here’s the thing: everyone’s brain works differently.

Some people thrive with deadline-driven task management. Others (especially many with ADHD) need energy-based or priority-based approaches. Some prefer visual dashboards, others minimal text lists.

There are simply too many preferences and ways of working for any standard system to work universally.

The #1 most utilized page in my Notion workspace is my “Today” page. It’s a daily dashboard that optimizes for taking daily action. I can see all of my daily habits, quickly add thoughts to my journal, quickly add new notes or access recent notes, access recently saved articles, review SOPs, create a new piece of content, etc. The dashboard is optimized for all the things I need to do in a day.

I could argue that this system uses GTD, or PARA, or any other number of productivity methodologies, because it brings together all of the core principles that every productivity system uses; it’s just woven together visually in a way that works for my brain.

Building Your Own Way Forward

Rather than searching for the perfect system, consider this approach:

1. Start with one universal principle

Pick something simple, like “capture everything in one place” or “review weekly.” Master that behavior before adding complexity.

2. Pay attention to friction

Notice where your current approach breaks down. What gets forgotten? What feels overwhelming? What takes too long? Friction often points to a system intervention opportunity.

3. Make small adjustments

Instead of overhauling everything, tweak one element at a time. Good systems evolve through feedback loops, not wholesale replacements.

4. Steal what works, leave the rest

Take the parts of different systems that resonate with your actual experience. Ignore the parts that don’t, regardless of how “revolutionary” they’re supposed to be.

5. Accept that it’s never “done”

Your system will inevitably need to evolve as your life changes. This isn’t a failure – it’s a feature. It’s normal to outgrow aspects of your system, remove pieces that no longer serve you, and integrate new features as needed.

The Real Skills You Need

Instead of seeking the perfect system, develop these meta-skills:

Systems thinking – Understanding how different parts of your workflow connect and affect each other.
Self-awareness – Knowing your own patterns, preferences, and constraints.
Iteration mindset – Viewing your system as an ongoing experiment rather than a fixed solution.
Building skills – Whether in Notion, Obsidian, or even paper, learn how to create custom solutions for your specific needs.

Instead of asking Instead of “Does this work with PARA/GTD?” you can ask:

Systems Questions:

• What are you trying to achieve overall?
• How do different areas of your work/life need to connect?
• What information needs to flow between different components?
• How will you maintain and evolve this over time?

Methodology Questions:

• Which frameworks serve your system’s purpose?
• What’s the best way to organize knowledge for your specific work?
• What task management approach fits your brain and workflow?

The Bottom Line

The productivity guru industrial complex wants you to believe their method is special. The truth is simpler and more empowering: the universal principles are already known. What matters is how thoughtfully you apply them to your unique situation.

Stop searching for the ultimate system, template, or method. Start building your own.

If you’re ready to move beyond system-hopping and learn how to build workflows that actually serve your needs, I’d love to work with you. My approach isn’t about giving you another branded framework – it’s about teaching you the skills to create whatever system works best for your brain, your work, and your life.

Check out our workshop on Principles of Dashboarding, or our signature program Notion Mastery.

The post The universal principles behind every productivity system appeared first on Notion Mastery.

Previously in Formulas you had to do a lot of work to copy automation-based formulas as described in my post Dealing with Copy and Paste Errors with Formulas in Notion Formulas 2.0.

No more!

We now have two new functions for helping us share formulas in automations.

Context

context accepts the name of built-in variables and data from an automation run and turns them into a valid Formula token. 

This means writing the formula context("Trigger page") will turn into the built-in Trigger page token when pasted.

And vice-versa! So when we copy a formula to share it with someone else, we get a nicely human-readable formula!

				
					
context("Trigger page")
	.prop("Project")
		.map(current.prop("Clients"))
		.flat()
		.unique()
				
			

Much better than how it used to copy:

				
					
{"global":"button_page","source":"global"}
	.prop("Project")
		.map(current.prop("Clients"))
		.flat()
		.unique()
				
			

Now I don’t have to do any cleanup work when copying and pasting in a Formula that was shared with me. Amazing!

So context is used in these built-in mentions. It’s also used when we use Add page in… steps in our automations. If you only have one, it’ll be a “Page added”…

				
					context("Page added").prop("Frame")

				
			

More than one? “Page added in step {n}”.

				
					context("Page added in step 1") + context("Page added in step 2")

				
			

Var

var accepts the name of a variable created in a Define variables step in an automation.

				
					"Hello" + var("Variable 1")
				
			

In the above, I would have created a variable called “Variable 1”:

When I paste in var("Variable 1"), Notion now auto-tokenizes this for us!

Copy and paste in automations means Formula examples are much more shareable and now that things are named exactly as they are tokenized, it’s much easier to understand what a Formula is doing at first glance.

A very welcome update to Formulas!

The post Notion Formulas in Automations can now be copy and pasted! appeared first on Notion Mastery.

The Feed view.

It’s a single column content feed that allows you to display content like a news feed.

The advantage of the feed view is that it shows a content preview without having to open the page. While this is similar to gallery and board views, the feed view shows much more content, including more advanced formatting with columns, and even linked databases:

You can even interact with the databases inside the content previews!

How might you make use of the new Notion Feed view?

My favorite Feed view use case is sharing life updates with family and friends!

When friends ask me, hows the kitchen renovation going?
How’s your garden?
What have you been cooking lately? What are your favorite recipes?
How’s the Invisalign going?

I can point them to a public page where I document my updates.

I love being a resource for others, so if something I’m learning or experimenting with is helpful to others, why not document it once, and share multiple times?

It’s also nice to have a place to point people to that isn’t owned by any one social media platform.

Here are three fun use cases where I’m using Feed view (and links in case you want to check them out for your own inspiration!):

Food + Cooking Journal (link)

Kitchen Renovation Updates (link)

Garden Journal (link)

How are you using Notion’s new feed view?

The post Celebrating Notion’s new Feed view layout appeared first on Notion Mastery.

I wanna tell you a little secret about “all-in-one” platforms:

They tend to do most things reasonably well, but rarely match the specific workflow you actually need.

My favorite example of this: figuring out what the Profit & Loss is for your business for a given month.

• Doing this in Quickbooks? Easy.
• Doing this in Notion? Extremely arduous.

You’ll hear a lot of consultants pose questions like,

“why use all these tools when you can just use Notion?”

And this isn’t just a Notion thing. It’s a platform thing. There’s indeed a good amount of consolidation you can do with tooling, but I always lead with the mantra…

“Just because you can do <ACTION> in <PLATFORM>, doesn’t mean you should.”

We document in a Notion database all the tools we use to operate our business. We keep track of who’s using what, how much it costs annually, when it renews, and so on. Last I checked the “core” stack of software we use to run our business (which is 90% Notion products, by the way) is about 25 technologies. Expanding to individual software licences, we start to get upwards of 100 different softwares we use to operate our little shop.

I’d venture to say about half of these are things that we could use Notion for, but would notably make the workflow much more arduous to manage. Essentially, we save considerable time and money by not using Notion to do everything.

On bookkeeping

One of the things I often see created in Notion is a financial management system—notably, bank account balancing, transaction categorization, and bookkeeping. Bookkeeping is one of those things that can be pretty simple if you run a simple business or are only documenting personal expenses, but in a digital business operating globally (multi-product, multi-language, multi-currency, et al) it can become complicated quickly.

Ours is most assuredly not a simple business when it comes to bookkeeping. I have rake and node tasks that automatically create bank transaction explanations in our bookkeeping software using Stripe and FreeAgent’s APIs. I use LLMs to massage screenshots of finance feeds that aren’t accessible into CSV’s that I can then run through ruby code to balance our accounts.

I’ve done 100s of hours of work over the years of multiple businesses and products to automate away much of the manual labour of bookkeeping. This is one of the places I want to reduce manual effort as much as possible.

And yet our bookkeeping software, FreeAgent, is one part of our software stack I would never port over to Notion. The software costs us ~$299/year to use. Doing this in Notion would not save me $299/year. In fact it would probably add $1000s of operational costs to my business, not to mention the downstream effects of having the books for our accountants be provided in Notion:

• Am I teaching my accountants how to use Notion now?
• How high quality is the export data out of Notion?
• Is my database setup conducive to how my accountants need it?
• Have I provided my accountants with the information they need in aggregate in a way that is understandable to them?

And this is where I make my stand. This is a hill I repeatedly throw myself on in death, but…

If you can afford bookkeeping and financial management software, you should pay for it.

Further, if you cannot afford bookkeeping software, then spreadsheets are the best software for financial management (Sheets, Excel, et al). This is because Notion is not spreadsheet software, even though table views look like spreadsheets and Notion originally advertised the product as “Replaces Sheets”.

Here’s why I advocate for paying for bookkeeping software:

1. Math is hard.
2. As a human, calculation errors are easy to make, no matter how intelligent you are.
3. Aggregation in Notion always requires a Relation. You cannot do simple pivot tables, calculations over multiple sheets, arbitrary data lookups, et al (Notion is not spreadsheet software, you know?).
4. Software designed for a specific purpose has lots of built-ins. For example, I could build a Profit & Loss calculation system in Notion, or I could just get it from my bookkeeping software, knowing that it is tested and accurate.
5. Because Notion is so complicated, new features have a tendency to introduce bugs. Quite frequently in fact. Startup, you know? Financial software is typically going to be less “move fast and break things” because breaking things is like “WE DIDN’T ACCOUNT FOR $100MM!” rather than “I CAN’T TRACK MY HABITS ACCURATELY!”.
6. Making mistakes on your finances can be very costly.
7. Software designed to do this gets new features specifically targeting the common workflows in the domain it’s designed for.
8. Your bookkeeper and accountant may fire you as a client if you give them access to a custom-built Notion workspace to work with instead of something like Quickbooks. Heck, we use a relatively well-known bookkeeping software, FreeAgent, and my accountant tries to get me to switch every year. They do not like anything that even remotely sniffs of a custom setup! (Okay, maybe you’ll find a bookkeeper out there who’s a Notion whiz, but I’m willing to bet there aren’t many that wouldn’t prefer you use software purpose-built for their job).
9. Even Google Sheets gives you access to GOOGLEFINANCE() which gives you access to real-time stock data and currency rates. Again, possible in Notion, but you’d have to use third-party software or custom software to update rows in a related database (remember, you cannot do aggregate data in Notion without a relation: NOT. SPREADSHEET. SOFTWARE.)

If you find building and maintaining this kind of system enriching, by all means, go for it! But there are so many cases where the actual workflows related to a system are better served by software purpose-built for that workflow.

Another example: mapping and travel planning

We planned our entire month-long trip to Japan in Notion. As we got closer to the date we also discovered this wonderful app called Wanderlog. One cool thing about building an application designed for travel planning and logging? Actual maps! Actual real-time location logging!

• “What’s happening near me right now?”
• “What’s near my hotel?”
• “Directions from A to B?”

Could you build Latitude and Longitude as Number properties into your Notion database? Create an integration that updates an embedded Google Map in the page? Could you use various APIs to fetch locations around other locations and populate a Locations database with suggestions?

Sure. Sure you could. But should you? Are you building a Notion Mapping integration or planning a trip to Japan? What are you actually trying to do here?

When you use dedicated apps that are designed for a very specific context, you’re going to get a lot of out-of-the-box functionality that you just can’t get with all-in-one-apps.

In this example, Wanderlong can auto-fill your days with suggested places (based on your starting location), as well as optimize your route with public transit! This reduces a ton of research work that would be required to manually input this information inside an app like Notion.

Similarly, Wanderlog also has built-in notifications of flight delays. There are lots of small details like this that are done for you, that simply couldn’t be done in Notion without extensive third-party support and API integrations.

Key workflow phases

This is where I get into thinking about where Notion as an ecosystem works best when considering different aspects of moving through a body of work. Let’s say we think of digital workflows in three key phases:

1. Planning — deciding how to take action
2. Doing — taking action
3. Reporting — documenting what happened when we took action

Most operational workflows fit into these phases readily. We plan projects, we execute, we let the team know how it went. We plan when to do chores, we do the chores, we have a page that reports the tasks we completed for the day because we designed a cool Notion view to highlight that to our family.

How about we take our Japan trip as an example of these phases:

Planning

• Where are we going?
• What are we doing?
• On what days?
• How are we getting there?
• Any events we want to see?

Notion shines here. Its block-based system gives us amazingly rich creative tools. We can plan our locations in a Locations database. We can associate Activities with those Locations in an Activities database. Maybe we think we’re going to eat a lot of amazing ramen so we plan to track our food in a Food database associated with those Locations. There’s so much amazing stuff to create in Notion here from Bookmark blocks for important links to PDF Blocks for tickets and information.

Reporting

Reporting in Notion is sensational. We can write about the food, review the food, we can take notes on each location. We can even write up a summary of the entire trip and bring in the content contextually via linked views of databases. We can upload our photos and videos and create Galleries, separating out our favourites with custom properties.

We’ve shared our Japan Trip Report with so many people planning trips to Japan and it’s been incredibly helpful!

Doing

Now we’re into the place where Notion starts to struggle in certain contexts. When we’re doing a very specific activity that is highly contextual.

Let’s say we wander through a city and discover a cool thing we want to do. We can use our reporting tools to track it. But if we’re looking to do other things in the surrounding area, the best we could do is link out to a Google Map with the latitude and longitude we tracked for the location. If we just discovered the location, we have to do the manual effort to capture that latitude and longitude to create that closed system loop.

This is where Wanderlog shines. It’s highly contextual. Locations are first-class citizens and components specifically exist to help you explore them, with the added context of orienting you in space and time.

So what might we might do differently?

I think of the core utility of Notion being synthesis of simple systems (which is what makes it complex, haha). Removing the busy administrative work frees us up to do more actually creative work, right? If I’m thinking about ranking the strongest parts of Notion for travel, I might rank it:

1. Reporting — Documentation, Notion’s meat and potatoes
2. Planning — Writing, capturing, layout; the best of Notion’s authoring abilities
3. Doing — We can take basic action on generic data, but without truly custom components designed to match the action, can be quite limiting without external integrations.

With that in mind, how might I tackle a next big adventure differently?

Firstly, I’d probably templatize the set of databases we created for our Japan trip. This immediately solves the reporting situation. Now, I might manually do the planning in Notion as well, but I think I’d do most of the planning in Wanderlog.

Perhaps I’d leverage Wanderlog Pro’s export feature to download all the places on my itinerary. Then I might write some code to import the data of all the places I visited or design my databases to work well with importing via CSV.

This allows us to leverage the power of both platforms, getting the awesome reporting and design power from Notion and the amazing doing (with maps and location-specific data) power from Wanderlog.

Aside: maybe there’s an amazing opportunity here to build a super in-depth Wanderlog integration for Notion.

Right tool for the job

Are you team Notion, Coda, or Airtable?

I’m asked this regularly. I’m team “right tool for the job”. You’ve heard that saying many times, right? Of course you have.

Sometimes I further extend this to a series of “rights”:

• right tool for the job
• right tool for the brain
• right tool for the context

Job

This one’s the most obvious. If you need to store 200 million records and calculate aggregations over these records, you’re not going to reach for Notion. It starts to show you its edges as you approach 100s of 1,000s of records, never mind millions. In this case you need a “proper” database, probably with high-availability, sharding, backups, etc. The Job is scale and speed in this case.

Now would you use a database platform and use automated reporting to push data in aggregate back to Notion for reporting? Yes. Would you used embeddings to bring charts and visualizations into a Notion page via an embed block? Absolutely.

Should you try to make Notion do this work and use its Charts product to visualize aggregates of 100s of millions of records? You could, but you might be limited in accessing the data and providing rich data in aggregate.

Brain

Many of our own business operational methodologies are related to the founders being neuroatypical—Marie diagnosed with ADHD—me undiagnosed (but sus on multiple fronts). Notion’s flexibility and design-forward tooling was instrumental for Marie. It helped us design systems that motivate Marie to action and provide me with more logical ordered systems that help me approach the same data-set in a way that was conducive to my particular approach. It’s elasticity for delivering data in different views is one of its strongest features.

We cannot all use the same approach. We can try, but often one person’s “eat the frog” is absolutely exhausting for another. So while Notion’s open-ended-ness and customization might help an ADHDer approach their work in a flexible way, it might also be nightmarish for someone who needs explicit structure, or teams that aren’t as comfortable in the messier complexities.

Doing the work of discovering who is on your team and how your teams work is a great precursor to selecting Notion as an orchestrator of systems. For teams that require significant flexibility and teams that are comfortable sitting in the discomfort of complexity, Notion can be an winning accelerator. For those that need a lot of structure or out-of-the-box best practices, it can be a real challenge.

Context

The contextual one is what I’ve been mostly talking about in this article. Is the tool suitable for your given context and/or workflow? Can it adapt easily to it or is there loads of maintenance and overhead in adapting to the context?

I often think that Notion—as a content management tool—is fantastic for managing the artifacts of a workflow (reporting), but that the workflow itself (doing) may be better off left to a context-specific tool. If that tool integrates well with Notion, well, now we’re cookin’!

So is Notion for me?

Like all software and all answers: it depends. But…probably!

Back when I was building custom content management systems in the 2010s, it’d take me 3 months to build what I can now build in Notion in 3 days. No-code tools allow us to get to 80% done with near immediacy. And sometimes this is perfect for our current needs.

And yet, you know what they say about the last 20%? The 80/20 rule says that the last 20% takes the same amount of time as the 80%. But I think it’s better to think of this rule as “you only really need to concern yourself with getting 80% of the way there most of the time”. So, yeah, there may be something custom you need to bring to combine with Notion to get a complete solution, but most of the time, it’s a fantastic tool for most of your email-job jobs.

There’s absolutely nothing wrong with continuing to use Google Sheets or Excel alongside Notion. In fact, that’s the entire point! We can’t (currently) use Notion Calendar and Notion Mail outside of Google products, so we can see these tools are necessarily meant to replace, but to synthesize and enhance.

Beware the temptation to do everything in one platform

No-code has given us the belief that we should build everything ourselves and save money. It is true—we can do more than ever—but we also need to remind ourselves that we have now consolidated all work into a single platform. As Notion changes, so now necessarily must our systems adapt to suite Notion’s design.

This is personally why, even though I use Notion all-day, every-day, teach it—pretty much live in it—I advocate for distributing important systems into tools that are custom-fit for the job. I love Notion as the orchestrator of sub-systems, but not the be-all-end-all. Single points of failure make me twitchy as a software designer!

Notion’s super-power is being able to “MVE” (Minimum Viable Experience) and iterate until you can either find a tool to do that exact system much better or build that tool yourself.

Notion gets us 80% of the way there, but sometimes the last 20% is the thing that actually impacts our lives/wallets/experiences and you should considering getting the 80% of that final 20% somewhere else.

Just a thought.

The post All-in-wonder syndrome: when Notion isn’t the right tool appeared first on Notion Mastery.

				
					async function createFileUpload(options = { mode: 'single_part' }) {
  try {
    const response = await axios({
      method: 'POST',
      url: 'https://api.notion.com/v1/file_uploads',
      headers: {
        Authorization: `Bearer ${process.env.NOTION_API_TOKEN}`,
        'Notion-Version': '2022-06-28',
        Accept: 'application/json',
        'Content-Type': 'application/json',
      },
      data: options,
    });

    return response.data;
  } catch (error) {
    console.error('Error creating file upload:', error);
    throw error;
  }
}

const upload = await createFileUpload();
				
			

				
					{
  "object": "file_upload",
  "id": "1f91c1cc-e3f3-810d-872b-00b2307e7303",
  "created_time": "2025-05-20T19:02:00.000Z",
  "created_by": {
    "id": "b289ce9d-156d-4e21-80b7-07212da8a537",
    "type": "bot"
  },
  "last_edited_time": "2025-05-20T19:02:00.000Z",
  "expiry_time": "2025-05-20T20:02:00.000Z",
  "upload_url": "https://api.notion.com/v1/file_uploads/1f91c1cc-e3f3-810d-872b-00b2307e7303/send",
  "archived": false,
  "status": "pending",
  "filename": null,
  "content_type": null,
  "content_length": null,
  "request_id": "42792711-7c67-4914-b1c8-447d8f629f89"
}
				
			

				
					// Single-part upload
const filePath = path.join(__dirname, 'data/example.png');
const fileStream = fs.createReadStream(filePath);
const file = await createFileUpload();
const upload = await uploadPart(file.id, fileStream);
				
			

				
					{
  "object": "file_upload",
  "id": "1f91c1cc-e3f3-810d-872b-00b2307e7303",
  "created_time": "2025-05-20T19:02:00.000Z",
  "created_by": {
    "id": "b289ce9d-156d-4e21-80b7-07212da8a537",
    "type": "bot"
  },
  "last_edited_time": "2025-05-20T19:02:00.000Z",
  "expiry_time": "2025-05-20T20:02:00.000Z",
  "archived": false,
  "status": "uploaded",
  "filename": "example.png",
  "content_type": "image/png",
  "content_length": 1152915,
  "request_id": "0925374b-c349-4bc4-b541-2554179a5d3e"
}
				
			

				
					const PART_SIZE = 10 * 1024 * 1024; // 10MB chunks for multi-part upload
const MAX_PARTS = 1000;

const filePath = path.join(__dirname, 'data/example.mp4');
const fileName = path.basename(filePath);
const parts = await splitFile.splitFileBySize(filePath, PART_SIZE);

if (parts.length > MAX_PARTS) {
  throw new Error(`File is too large. Maximum number of parts is ${MAX_PARTS}.`);
}

// Create multi-part upload
const file = await createFileUpload({
  mode: 'multi_part',
  number_of_parts: parts.length,
  filename: fileName,
  content_type: 'video/mp4',
});

let upload;

for (let i = 1; i <= parts.length; i++) {
  const fileStream = fs.createReadStream(parts[i - 1]);
  upload = await uploadPart(file.id, fileStream, i);
}

// Complete the upload
upload = await completeMultiPartUpload(file.id);

// Clean up temporary files
for (const part of parts) {
  await fs.promises.unlink(part);
}
				
			

				
					async function attachFileAsCover(upload, page) {
  return await notion.pages.update({
    page_id: page.id,
    cover: {
      type: 'file_upload',
      file_upload: {
        id: upload.id,
      },
    },
  });
}
				
			

The post Uploading Files via Notion’s API appeared first on Notion Mastery.

For example, if we have a Multiple choice field that maps to a Multi-select property…

1. Click the “…” option on the Form element.
2. Click “Add conditional logic”

This adds “logic” to the “Question 2” question. Then we can…

1. Only show the fields in the toggle when “Option 2” is selected
2. Add as many fields as you like to show when that condition is matched

As you can see, the logic is pretty basic. It’s a value matching system. My current understanding of the system is that conditional logic is an exact match system and can only be added to the following properties:

• Checkbox
• Select
• Multi-select

The current limitations of the system as I’ve observed are:

• You can only add a single exact matching condition (no AND/OR logic as with Filters)
• Conditions are explicitly tied to a single input, so we cannot add logic that observes conditions of multiple inputs
• Since it’s an exact match system, we cannot add conditions like “if the text field contains the word ’emergency’…”
• You can only add two levels of conditions (Grandparent > Parent > Child) (see image below for the max number of nested conditions)

Regardless of the limitations, this definitely improves Notions Form product, and I’m looking forward to them exploring this feature further.

The post Notion Added Conditional Logic to Forms appeared first on Notion Mastery.

And, of course, the first thing that Notion users noticed wasn’t the feature, but that the feature is only available to customers paying for Business or above plan.

In fact there are a ton of incredible features on Business and Enterprise, especially for growing businesses that might be experimenting with a Free or Plus plan Notion workspace. Today we’ll be having a look at the Plans and why would might select one or the other for your business.

Plan Overview

You can always get an overview of the features and access on Notion’s pricing page.

Notion offers a Free plan as well as paid plans: Plus, Business, and Enterprise. I really do not recommend attempting to run a business on the Free plan. And setting up your business at minimum will really require at least one paid Plus seat.

You pay for Notion per user. Paid users are called Members. You can also give access to pages to a certain number of unpaid Guests. The limitation of guests is they:

• Cannot be added to groups
• Cannot be granted access to teamspaces as they can only be added to pages (this makes them a bit of a nightmare to administer at scale)
• Cannot add automations
• Numerous other limitations

The guest limitations per plan (i.e. how many guest users you can invite) are:

• Plus: 100
• Business and Enterprise: 250

So which is right for your business?

My recommendation? If you’re just getting started and you’ll be the only user for a bit, you can buy the monthly Plus plan and transition to Business or Enterprise once you start onboarding collaborators and get a feel for what using Notion at scale is like.

In the long-term, once you’ve established Notion as a core tool in your organizational stack and have settled on a Plan that works for you, you can then transition to yearly billing.

One of the unfortunate side-effects of Notion’s seat-based billing model is that once you’re on a yearly plan, to add a member temporarily will mean paying for a year’s worth of access for that seat. So don’t transition to yearly billing until you’re confident Notion is solid for your team and you have an idea of what you’ll expect to pay as your team grows.

The Plans

Plus

Many businesses can get away with the lowest paid tier. The primary features you’ll miss on the Plus plan are:

• Private teamspaces
• Form conditionals
• Page Verification

Private teamspaces are really useful on a business level. For example, you can have completely hidden teamspaces for Legal and HR and special initiatives.

You can get around this by using Closed teamspaces, but be aware that these teamspaces and the titles of the top-level pages in them can be seen by any member of your workspace (guests cannot see these), so if you utilize this workaround, consider naming your top-level sidebar pages something rather innocuous and not like “Plan to sell the company for parts 2025”.

Business

As noted above, Business gives you access to private teamspaces, form conditionals, and page verification. You can get 250 guests instead of 100, increased page history, and access to SAML-based single sign-on (or “SSO”).

SAML, or “Security Assertion Markup Language”, is a standard that means you can switch to signing users into Notion via your own platform or website. This can be pretty critical if you need to manage your Notion member accounts on your end rather than allowing users to have their own accounts.

Other helpful business features include:

• Export members as CSV
• Verified domains

Enterprise

If you’re serious about Notion being the core pillar of your organizational stack, I recommend the Enterprise plan. The highest-cost plan has key features for administrators and security-conscious IT professionals including:

Audit log

This searchable and filterable log allows you to see what every user and automation is doing in your workspace. Very, very helpful for diagnostics when things go wrong.

Content search

Find and administer any page in your workspace. Also why you should recognize that private pages are technically not private in an Enterprise workspace as workspace owners can indeed add themselves to private content or assign those pages to an administrator when a member with private pages is removed from the workspace.

User provisioning

Use Notion’s SCIM API to add members to the workspace and groups. Pretty key for large organizations or those who would want to leverage SAML, this allows you to provision users automatically and assign them to necessary groups.

We leverage SCIM in the NOTION MASTERY workspace and I wrote up a guide on how we leverage this powerful API here.

Custom permissions

On enterprise plan, you can override permissions at the teamspace-level. So you can give custom access to entire teamspaces via groups which can be super helpful for administrative purposes.

Security & compliance tools

Enterprise gives you way more control over what your members can do in the workspace.

• Disable public page sharing
• Disable guests entirely
• Disable exporting content
• Disable webhooks
• Disable connections
• Integrate with SIEM and DLP tools to automatically centralize audit logs & set policies to detect sensitive content in your workspace and trigger automated actions to remediate

Many of these features are going to be critical at larger businesses with security protocols that need to be followed. For example, disabling connections might be a great idea so your members aren’t adding “vibe-coded” AI apps that give access to critical business data.

Domain and user management

Domain management allows you to manage multiple workspaces under the same organization. So if you’re a 1,000 person company, you might have separate workspaces for each of your Teams, each with their own administrative people and systems. Being about to “Claim workspaces” allows you to set the same settings and policies across all these workspaces, while giving each workspace some flexibility in how they ship their workspaces.

The Cheap, High-maintenance Route

There is one way you can pay for a smaller numbers of a seats. I’m not going to sugar coat it: it’s a maintenance nightmare, and you’ll severely limit what you’re able to do with Notion long-term, but you can use single-page architecture to structure your workspace so you can invite as many guests as your plan allows.

I do not recommend this strategy, but for those that need a single or a few member-architects and lots of, say, read-only guests, this can be effective. What this means is not using the teamspace sidebar to organize multiple dashboards and pages, but leveraging a single page with all databases and content nested inside.

The downside is that:

• Every guest has to be added manually to the top-level pages since guests cannot be added to groups or teamspaces
• Permissions overrides have to be manually done for every single guest (mistakes are very easy to make)
• Guests cannot do anything with automations and many other features
• Guests are exposed to other guests (both email and name) with the same access, so you will expose collaborator data to your other collaborators with this strategy)
• You are limited to 100 guests on the lowest tier plan and only 10 on the free plan

The post What Notion Plan is Right for Your Business? appeared first on Notion Mastery.

As always, features tend to ship out progressively with Notion, so if you don’t have this feature in your workspace yet, hold tight; it’s coming!

Let’s dive in!

To start, here’s what it looks like:

In short, we now have a navigational component which features a Content tab which hosts our properties and page body content as well as any number of Tabbed Views, which are like Linked Views but they persist through all pages in the database. Where we add linked views to page bodies, we add tabbed views to Notion page layouts.

To access this new layout mode, first hover over the heading of a page in a database to reveal the “Customize layout” button:

Once we’re customizing the layout, to switch into Tabbed structure, click the Page Settings option in the top-left:

This will reveal the Page settings in the right sidebar. You can see there are two options for Structure now.

• Simple — the default Notion page layout. This is what we all know and love.
• Tabbed — Adds a “Content” tab as well as the option to add additional database views as tabs.

You’ll also note the option to toggle on/off Property icons in this view and they’ve moved the Full width page setting here as well. Other page settings options like comment and discussion style have been moved here as well.

Unlike linked databases in templates, tabbed views exist on every page of the database. If you’re accustomed to making template changes and then going back and reapplying the template to a bunch of pages, this is going to make life as a Notion designers a whole lot easier.

Once you’ve enabled Tabbed structure, you can find the Content tab (1) added underneath the Heading area of the page layout.

You can add views to this tabbed interface by clicking the + button (2).

This presents us with a view-creation picker which gives us all the relations to the database the page we’re customizing is in. Selecting one of these will create a blank view and add a new filter to the view with the new Page containing this view selected as the filter. This new special expanding filter will ensure that the view only shows content related to the page.

This is added as a Quick Filter at the top of the view. You can of course modify the filters and even add this filter to an advanced filter to further customize the view. To modify all our standard view properties, we select the tab and use the standard configuration which is presented in the right-hand sidebar.

This is where we do all our standard view customization work we’ve had for a long time in Notion such as customizing the icon presented in the view tab, the name, layout, properties, filters, sorting, and group.

Advantages

The advantage of this new layout system is that we’re now able to create persistent application-style UIs for our databases which are the same from page-to-page. No more views being outdated or having to reapply templates to 100s of pages. Simply make a change to your view and it is updated across every page in the database. Wow!

One of my favorite little additions which I’m hoping comes to linked views as well is the ability to Link exiting pages through the relation in a tabbed view. This improves the process which previously would mean having to access the property directly on the page instead of linking existing records through a linked view.

Disadvantages

You cannot as a builder interact with changing these views outside of layout customization mode. So you’re having to open the layout editor to make any changes. You cannot modify and then “Save changes” the way you can with a traditional view embedded in the page. For advanced users, this may be frustrating enough to prefer linked views over tabbed views.

There are also some permissions issues with the initial iteration that may be difficult to navigate in a shared or team workspace. I’ll get into those shortly.

Property Interactions

Both properties and page body content are presented as part of the Content tab. So if you switch to a secondary tab, your page properties will be hidden. However, the page title and pinned properties will persist in being displayed through switching to any view.

Permissions Bugs

After playing around with this feature in some shared workspaces, I found some notable issues with the feature. For example, if you add a view that is not related to the current database page…

…if the user does not have editing permissions on the database this view is attached to, they will not be able to modify content or add new content via this view, even if they have Can edit content permission on the source driving the view.

This can be problematic if you are running a multi-player workspace that is not all Full access as a sane Notion administrator should. Hopefully this will be fixed/improved soon!

Other Limitations and Issues

• You can at this time only have one Content tab.
• I’m currently tracking a bug where I actually have two independent Content tabs, one of which is non-functional. I expect this to be patched this week some time.
• Sometimes when you are configuring a view tab, the content will be completely empty even though there are related pages. This can make customizing the view very challenging without a preview of your data.

The post Tabbed Layout Adds Application-style UI to Notion appeared first on Notion Mastery.

With a few clicks you can automate the setup of some of your most common project workflows, creating fully automated workback schedules based on an initial project date.

If you have large projects that have standard project phases and standard tasks that occur each time, you can set up a single automation to help you do the heavy lifting (in Notion) of setting up sub-projects, automatically applying templates, setting project and task dates, and automatically connecting relations between your projects and tasks.

In this video I do a walkthrough of how to set up this sort of automated workback schedule, as well as demonstrate some variations that include adjusting date ranges based on a launch date or project start date.

You’ll need:

• A Projects database and a Tasks database, with a two-way relation between the two.
• A two-way self-relation from your Projects database to the same Projects database for creating a parent-child relationship.
• A Status property in your Projects database for activating the automation (or use one of your existing properties).
• A Parent Project rollup in the Tasks database that looks up the Project Relation > Parent property (allowing you to always identify the parent project from every sub project).

How it works

You:

• Add a new project in the Projects database using a parent project template.
• Add a date to specify when the project should be completed.
• Change the Status property to “Activate”.

Notion Automation:

• Creates X number of sub-projects inside the Projects database with dates auto-populated, and templates automatically applied.

You:

• Open the parent Project page.
• Open the first sub-project (phase) page and click the button to auto-populate all sub-project tasks.
• Repeat with each project phase.

Notion Automation:

• Creates all tasks in the Tasks database, related to the project, with dates auto-calculated based on project dates.

How to set it up

Create a Parent Project Template

• Create a new template in your Projects database.
• Make the page full width in the project settings:

• Set the Sub-Projects property to Always hide. Why? You can’t do anything in the property area except add/remove projects, and this takes up valuable real estate. We want to manage the projects in the body of the page through linked databases, which allows us to filter, sort, and manage the data.

• In the body of the project, put a linked view of the project database (Type /linked and search for your Projects database).
• Add a filter where Parent (Project self relation) = [The Project Template name].

Repeat the same process with the Tasks Database:

• Below the Projects database, create a linked view of the Tasks database.
• Add a filter where Project contains the Project Parent Template, OR where the Parent Project contains Parent Project.

This will allow you to see all Tasks from all Projects that are connected to the Parent Project.

Turn on Group by Project, which will allow you to collapse the different project phases and only see the ones you need to see at any given time (to reduce overwhelm).

You can manage all sub-projects and tasks from this project dashboard, or go to each individual sub-project page to manage tasks within each phase.

Create a Sub-Project template for each phase

Alternatively, if you don’t want to create different project templates, you can create a single sub-project template that contains all task buttons for each phase, but I think it’s easier to create each sub-project phase!

• Create a new project template
• Use the same process as above, adding a linked view of the Tasks database, filtered to Project contains [template name].
• Create a button to auto-populate your tasks through an automation.

Once all of your project templates contain all necessary buttons with all your required tasks, you can set up the automation on the Projects database.

Create the Projects database automation

• Add a new Automation to the Projects database.

• Set the trigger that will kick off the automation. In this example, I have created a Status of “Activate”, but you can use any other desired trigger.

• Set the “Do” actions to “+ Add page to [Projects] using [Desired Template]”.
• Set the Date property using a formula. This is where the heavy lifting happens!
  • Using dateSubtract, we can subtract time from the date in the trigger page (the sub project’s date), allowing us to create the workback schedule.
    You can subtract days, weeks, months, or years, etc (or use dateAdd to add time to a date)

• Set the Date property for each sub-project phase as desired.

Making sure it works

• Test the automation with a test project. Do the dates look right?
• Make any adjustments to your formulas or templates as needed.
• What other property updates could you automate along the way?

The set up takes some time, but once it’s in place it can save you hours of set up time!

Enjoy.

The post How to Create a Workback Schedule with Notion Automations appeared first on Notion Mastery.