I approach every Notion workspace with a core tenet. In its simplest terms:
Use databases, not pages.
Among the myriad benefits of this strategy, it positions your workspace to integrate seamlessly with other services, facilitated by Notion's new API.
Below, I expand on this principle, then explore how it serves the API.
The Bulletproof Principle
Why use it?
As the foundation of The Bulletproof Workspace, my core tenet—databases over pages—is known as the "Bulletproof Principle." Aside from supporting the API, it:
keeps your information accurate and consistent;
minimizes redundancy and vulnerability to human error;
automates contextual filters;
summarizes information and derives useful insights;
retains your ability to scale and migrate your content; and
leverages Notion's most distinctive advantage: the union of databases and documents.
You can remember the Bulletproof Principle with the acronym CMD+ACT ("Command and Act"):
Centralize in master databases.
Access from contextual templates.
I detail the approach in my walkthrough of The Bulletproof Workspace, but here's the gist:
At the top of your page hierarchy is a "Headquarters" page.
At the bottom of that page, subtly tucked into an "Admin" toggle, is a page called "Master Databases," which centralizes your information in master databases, such as People, Tasks, and Resources. You rarely access that page directly:
Instead, you access your information through Linked Databases, which are linked instances of your master database that are filtered and formatted for various contexts.
Linked Databases within your "Headquarters" page offer a high-level snapshot of workspace activity, such as active projects, pressing tasks and upcoming meetings:
Linked Databases also exist within each other. You can open any database item to see related items from other databases. For example: you can view tasks within projects, employees within companies, and key results within objectives:
These databases-within-databases populate automatically from preconfigured templates that utilize self-referencing filters.
An example implementation.
Here's a microcosm of a workspace built on The Bulletproof Principle for the company Loggerhead Labs:
At the highest level, within the sidebar, is the page Loggerhead HQ.
Subtly tucked within an "Admin" toggle is the page Master Databases, which contains these master databases:
Projects
Tasks
Notes
Meetings
Resources
Items across these databases form natural relationships, which we establish in Notion using Relation properties:
Projects relate to Tasks, Notes, Meetings and Resources.
Tasks relate to Projects and Meetings.
Notes relate to Projects and Meetings.
Meetings relate to Projects, Notes and Tasks.
Resources relate to Projects and Tasks.
Database items can then become their own contextual dashboards, filtering other databases to display only related items:
The inner page of each project displays its tasks, meetings and resources.
The inner page of each meeting displays its projects, notes and tasks.
These contextual views are automatically created using database templates with self-referencing filters.
Common Contextual Views
These are among the most common contextual views of master databases, facilitated by relations and automated with templates:
Relationship Management (CRM)
Within Prospective Clients (a category within the People database), display relatedEmployees, Meetings, Notes and Resources.
Within ActiveClients (another category of the People database), display relatedEmployees, Projects, Tasks, Meetings, Notes and Resources.
Project Management
Within Spaces (categories of life or work), display relatedProjects, Tasks, Meetings, Notes and Resources.
Within Projects, display relatedTasks, Meetings, Notes and Resources.
Within Clients (a category of People), display relatedProjects, Tasks, Meetings, Notes and Resources.
Within Meetings, display relatedProjects, Notes and Tasks.
Within Spaces (categories of life or work), display relatedResources.
Expense Tracking
Within Expense Categories, display relatedExpenses.
Within Vendors, display relatedExpenses.
Within Years, display relatedExpenses.
Within Quarters, display relatedExpenses.
Within Months, display relatedExpenses.
Education
Within Courses, display relatedNotes and Assignments.
Within Assignments, display relatedNotes.
Apply the Bulletproof Principle to the API.
What's the Notion API?
Rolling out incrementally, the API allows Notion to interact with other services, including:
calendars;
email marketing and automation services;
CRMs;
reporting tools;
communications channels;
accounting software;
content management systems (CMS);
ecommerce services;
membership platforms; and
virtual assistants.
Here are a few examples of what you can do with those integrations:
sync Google and Outlook calendars with an events database;
maintain an integrated, unified contact list;
send personalized emails in bulk;
collect form submissions;
aggregate and visualize reporting metrics;
send Notion content to Slack channels;
sync QuickBooks or FreshBooks with databases of invoices and expenses;
maintain your website's content in Notion;
sync your Shopify or Gumroad store with a database of orders;
sync members from MemberSpace or Memberful with a database of members; and
update Notion databases from Alexa and Google Assistant.
Who creates these integrations?
The services create official integrations.
A growing number of services use Notion's API to create official integrations. You can choose those services directly within Notion. Conversely, you can choose Notion within those services.
Users create custom integrations.
Additionally, users can use tools like Zapier to create custom integrations. (I'll be posting to Zapier's blog throughout the rollout of the API.) These services will allow you to connect Notion to other apps, then define "triggers" and "actions." In other words, "if this, then that." For example:
If a task is completed, then reschedule it.
If it's the first day of each month, then email a report to stakeholders.
If a prospect enters a sales stage, then send a text message.
If a content database is updated, then update the website.
The constant: Databases.
Every example above uses a Notion database. More specifically, it references or updates properties of a database. For example:
A synced calendar event exchanges Title, Date, Time, Description, and so forth.
A synced contact exchanges First Name, Last Name, Email Address, Phone Number and Birthday.
A mass email sent with an ESP includes Message, Email and personalization variables, like First Name, for each recipient.
Imported ecommerce orders include Order ID, Customer Name, Customer Address, Customer Email, Products, Subtotal, Tax, Shipping Cost, and Total Cost.
That's how the API works most often and most seamlessly; it links properties from your Notion databases to values in other services.
By upholding the Bulletproof Principle, and thus using databases for all content, you'll prepare your workspace to leverage every integration. Those capabilities will expand over time, but your commitment to the framework will ensure your ability to implement each new opportunity.
Common Master Databases
As you apply the Bulletproof Principle to your own workspaces, consider the below master databases. To learn more about the way they coexist under the Bulletproof Principle, explore The Bulletproof Workspace.
All Workspaces
Spaces (High-level categories of work or life.)
Resources (Catch-all for referential information.)
Organizations
People
Media (Books, articles, movies, podcasts, television shows, etc.)
