In this article, I will show you step-by-step how to create a project management system on Notion on my own. The description and the “construction process” are simplified to make the article shorter and more easily readable.

If you do not want to do it yourself or start from zero, at the end of the article there is a link to a ready-made free system template (which can be edited).

Notion is a unique tool that makes it possible to create a personal or corporate system for anything.

We start by planning the most important part of the system - the database structure, it is the foundation and it will be difficult to change it later.

To understand how many databases to do, we need to imagine what we need to get out: and know something about how Notion works:

• Suppose we want tasks and it to be combined into projects, we also need meetings, we need to be able to create or have quick access to documents and understand who works in our system (people) and each person has their own personal dashboard, be able to ask and receive answers to work questions (knowledge base) inside the system, and everyone should see these questions before asking their own.

• Access levels. In Notion, we cannot provide access to a person (for example, only to their tasks), we either provide access to each task separately manually, or give access to all tasks. That is, to separate access, you need to separate the databases. We will make 3 levels of Access:

1. Tasks, meetings and questions;
2. Tasks, meetings, questions, documents, projects;
3. Access to everything.

• Now we need to answer the question: how many records will we have approximately created in databases in 1 year? Why do you need to know that:

Unofficially, according to user reviews, there is a “threshold” for the number of records in the database, after which it can start working “slower” if it is connected to other databases - this is about 10,000 records.

The more connections, the worse.

1. 1000-5000 - you can create several databases connected to each other.
2. 5000-10000 - it is better to make a structure with a central unified database (or as few of them as possible).
3. More than 10,000 - it is worth designing a system taking into account the data archiving mechanism, or looking for another tool.

In practice, much depends on the details, but these ranges can be used as an approximate guideline. We choose the first variant, so our scheme looks like this

Now we need to understand: what functions do we need/what do we want the system to “do”?

At this stage, it is very easy to come up with a lot of functions, automations (more on them later) and other things, but we keep in mind 4 complementary “thoughts”:

1. Gal's Law (indirect quote):"Any working complex system develops on the basis of a working simple system. Complex systems created from scratch will never work in the real world, because they were not influenced by environmental selection factors during the development process."
2. The rule of good design for anything: “Less is better”
3. Any fictional process with a high probability will not work.
4. The more actions people have to take, the more resistance there will be to the system. Even if it will eventually save them time and effort.

We approach the design-planning process as follows:

1. We make a list of all the desired “functions” and divide them into groups: - It is necessary;-Most likely it is necessary;-It would be nice…
2. We select the necessary ones and what we are already working with / used to, and leave the rest of the ideas for later.
3. We are creating a document that will be quickly accessible to all people who work in the system, where you can leave comments: what doesn't work, what can be improved. We focus on problems, not solutions. People see the problem well, but often do not understand how it can be solved.

We get this list:

Task Functions:

• Due date - when the task should be ready;
• Result - Before completion, it describes what will be the result of the completed task;- After execution, a link to the result or the result itself (text) can be added here;
• Before execution, it describes what will be the result of the completed task;
• After execution, a link to the result or the result itself (text) can be added here;
• Responsible - who performs the task;
• Done (Checkbox) - to mark the completed task;
• When the task was actually completed;
• Notification that the task is overdue;
• Links to other databases: Projects, Questions, Meetings, Documents;

Project Functions:

• The same as the tasks, only in the links instead of the Projects of the Task;
• Progress of completion - shows as a percentage how many tasks have been completed out of the total number of tasks;
• How many days are left until the end of the Deadline.

Meeting Functions:

• Date and time;
• Location - Location - venue/link to a meeting or physical address (you never know);
• Leader;
• Secretary - who draws up a document based on the results of the meeting and distributes Tasks in the process;
• Participants;
• The agenda - what will be discussed at the meeting;
• To fill in the protocol, there is a formula that will combine: the date, the name of the meeting and the names of the participants. It is copied and pasted into the protocol by pressing two buttons.
• Links to other databases: Projects, Tasks, Documents;

Why do I need a separate meeting database ?:

1. As a result of the meeting, a protocol document is created, which is uploaded to the document database.
2. Tasks are assigned and distributed at an online meeting.

Document Functions:

• Creator;
• Date of creation;
• Verification - up to what point the document is relevant;
• Document type - we will have 2:
• Minutes of the meeting;
• Instruction manual;
• Connections with other databases: Projects, Tasks, Meetings, Questions.

The Functions of The Questions:

• Creator;
• Date of creation;
• The answer is a text field where the answer is placed;
• The responders are the person or people to whom the Creator addresses the question;
• Department - which “department" should the question-answer relate to, for example, let's do 3: IT, Finance, General;
• Links to other databases: Projects, Tasks, Documents.

What a separate database of questions is needed for: to preserve and reuse knowledge and to improve the efficiency of the workflow through Indirect communication.

1. Before asking a question, a person searches (Notion has a normal database search) whether this or a similar question has already been answered, and each new answer forms a knowledge base.
2. The person answering (the one to whom the question is addressed) is not distracted from the current work (and does not get lost), but answers the question when it is convenient (within the established processes).

People's Functions:

• Name;
• Mail;
• Telephone;
• Accesses (what a person has access to);
• Personal Dashboard: we want each person to have their own page where they will see only their tasks, meetings and questions addressed to them. To do this, a separate Dashboard database is being created, which will not have any functions.

The main task of the people database is to contain all the information about the people who work in the system. The highest level of access is needed to this database.

We also add automatically populated technical functions to all databases.:

• When the record was created;
• Who created it;
• When was the last time the record was changed;
• Who changed it;
• ID is the unique identification number of the record.

Here we intentionally limit the number of functions necessary, so we will not select and compile a list of "secondary” ones. But in a normal process, there is such a step.

1. Each Person will have their own dashboard where they will see:Access Level 1: Tasks, Questions and Meetings;Level 2 access: everything on the first level + Projects and Documents.
2. For the top 3 levels of access, we will make a central dashboard, which will show everyone who is doing what and general indicators of “efficiency”.

Before moving on to “construction”, I would like to emphasize once again the importance of planning - this is the foundation and you should always start with it.“Measure it seven times, cut it off once.”

Even in the process of planning this simple system, I realized that “in my head” I did not take into account some things. When we write down or “draw” ideas, the thought process begins to work differently, and the overall initial view changes. 

Here I will not explain in detail how to work in Notion (which buttons to press, etc.), the article has a different purpose.

More details, button pressing and the process itself are in the VIDEO 

All in turn, right on the same page (inline): this way it will be faster to work and configure:

After that, we link them together (create a Relationship property):

Great, the structure is ready. 

To each database, according to the above list:

• To fill out the protocol, this is a formula in which one should be collected: the date, the name of the meeting and the names of the participants. The formula looks like this:

formatDate(prop("Date/Time"), "DD.MM .YY HH:mm") + "
"+format(prop("Name"))+"
"+"Presenter-"+format(prop("Presenter"))+"
"+"Secretary-"+format(prop("Secretary"))+
"Participants: "+prop("Participants").map(name(current)).join(", ")

• The notification that the task is overdue is a formula that works logically: if Ready is not marked and the Deadline has passed, then the field returns a red circle.The formula looks like this:

if(and(prop("Term") < now(), empty(prop("Done"))), "🔴", "")

• Project progress - create a rollup property, select the link to the Tasks, and the property is ready. We want to see the percentage of “crossed out” i.e. completed tasks.

• How many days are left until the end of the Project period is a formula that works logically: if the Deadline is not empty and the project is not Ready, the formula returns the number of days and hours until it is Ready (or how many days overdue).The formula looks like this:

if(!empty(prop("Term")) and empty(prop("Done")), ((format(dateBetween(dateEnd(prop("Due date")), dateStart(now()), "days")) + " d ") + format(dateBetween(dateEnd(prop("Deadline")), dateStart(now()), "hours") % 24)) + "h", "")

Well, at the end we will add a description of these functions so that when you hover over them, you can see / understand what they are doing. This is very useful when there are many functions. 

We use Concept automation: everyone can use them, but only owners of paid tariffs can configure them.

We add auto-filling of the date/time when they were completed to Tasks and Projects (when the Done checkbox is “crossed out");

 🚀 Internal automations are very limited, to expand the capabilities and link Notion with other applications, you can use third-party “automators” Zapier or Make. This makes it possible to atomize almost anything and create an interconnected system from a variety of applications.

Next, we will add 2 more internal Notion tools that also automate the process and save a lot of time - templates and buttons.

If the Projects or Meetings are always the same or almost the same, we can create a template for this. We will also make a template for a Personal Dashboard.

In all 3 templates, there will be “views” on databases, and I would like to explain 1 important principle related to this, using the example of Projects.

Projects

There will be 4 types inside the project template: Tasks not done, Tasks done, all Tasks and Appointments.

First, create the All Tasks view, click the filter, select the project connection property and select this template in it.

 Now only tasks related to this project will be shown here, and when we create a task on the Project page made using this template, it will be automatically linked to this Project.

Now we duplicate the view of All Tasks 2 times and change the filter in each so that it shows only the unfulfilled and completed ones.

We add sorting to all 3:

• To the unfulfilled - with an early Deadline on top;
• To completed - with the nearest (late) Deadline on top;
• To all - with the nearest date/time of creation on top.

In Meetings, we also set a filter binding to the Meeting template and sort with the nearest date/ time of creation at the top.

In the Meeting template, we will have one type - tasks. Which is needed in order to distribute tasks directly at the meeting, after which these tasks will have a connection with it.

We will have 2 types of personal dashboards: for access level 1 and 2

Level 1 - views on tasks, meetings (as a list and as a calendar) and questions;

Level 2 - Views on tasks, meetings, questions, projects and documents;

We make a separate section for meetings, breaking down the types by filters: where a person is selected as a presenter, as a secretary and as a participant.

We “pre-configure” all the Filters (picture) and when creating a new dashboard, select a person in the appropriate property:

• Responsible for projects and Tasks;
• Answering the Questions;
• Participant, secretary and moderator in Meetings;

Buttons can save a lot of time when, for example, we have a type of project in which the task list is always the same (or almost the same).

We can't just add this task list to the template (Notion doesn't work that way), but we can create a button in the template, when clicked, the Project will be filled with a list of pre-completed tasks that are associated with this project.

Such buttons are created for individual processes, we will make a simple example to show the principle :

Now we can proceed to setting up the view of the main dashboard for access No. 3.

• Tasks (completed, not completed)
• Projects (completed, not completed)
• Meetings (table, calendar)
• Questions (answered - The answer is empty, and not answered)
• Documents, by type
• People
• Dashboards
• Activity (who edited what last)

There are many such pages and views that can be created, but you need to proceed from a real need.

This concludes our simplified demonstration construction.

In conclusion, I would like to say that there is a lot more to do and create in Notion, but the main idea that I would like you to take away is that you can create exactly what you need.

You can also add third-party automation to this by combining all (or almost all) of the applications in which you work into one, semi-automatic system.

The limit here will be your imagination.

The template of the system created above can be obtained for free here.