Notion: The Swiss Army Knife of Productivity

Software

Sunday, November 14, 2021

Notion is a multifaceted all-in-one workspace & organization tool that works well for personal notes, collaborative projects, journals, and much more. As a tool that’s been around for many years, it has gathered a large following around many communities, being comparable to a Swiss Army Knife in the productivity world. Its freemium model combined with the massive amount of features has made it appealing for both people independently and teams at work.

Notion themselves say that their feature set replaces lots of popular existing software: the wiki-like structure allows for powerful organization akin to Atlassian’s Confluence and GitHub’s Wiki feature; the representation of data in popular formats such as tables, lists, and Kanban boards replaces Atlassian’s Trello and Jira and Asana; and the rich notes feature replaces Google Docs, Evernote, Microsoft Word, OneNote, and many popular markdown-based note-taking software like Typora.

The theoretically unlimited amount of content that can be stored combined with the ability to add guests to a workspace makes Notion quite powerful, but the easy-to-use interface along with the aesthetically appealing experience creates a piece of software that is close to ideal for many purposes.

Availability

Notion is available as a web application at the URL notion.so, so it’s not required to download anything. However, there are apps for both macOS and Windows, which are wrappers of the web app. There is no official support for Linux systems, but third parties have created packages for them.

Notion is also available for mobile devices, both iOS and Android on their respective app stores. The mobile app, delightfully surprisingly, has nearly all the features of the desktop applications, much to the contrary of many software companies who have taken the approach of “less is more”, removing seemingly unnecessary features for the extra minimalism. The mobile apps support direct dragging on blocks to move them, so they are more than a mobile wrapper of the desktop client.

Getting started

Notion is quite user-friendly, as stated before. After signing up, the user goes through the workspace creation process, choosing a name for it. Once created, the user is redirected to that workspace, where there are a few template pages that show off a bit of the functionality Notion has. Immediately, the user can start creating pages and typing away.

Pages

Pages are the cornerstone of every workspace, which can have unlimited. Each page has a title, which is displayed at the top of the page as well as in the hierarchy on the left sidebar. Along with this is an icon that can be chosen- by default, there is none, resulting in empty space at the top of the page and a default paper icon in the sidebar. The user can choose from a list of emoji to use as an icon or can upload an image of their own. It will appear above the title on the page. Lastly, pages can also have covers, which are shown as a banner, spanning the top portion of the page (it is not shown on the sidebar). A few dozen default covers are included, with themes such as solid colors, gradients, NASA images, and museum photos. There is also built-in support for Unsplash, a popular stock imagery service, and of course, the ability to use a custom image via uploading or pasting a URL.

Pages are made up of blocks and can be organized in a hierarchical form with sub-pages to many levels being supported. This allows pseudo-folders to be created for a more traditional organization look. These can be collapsed and expanded at will.

Since workspaces can be shared, there is also the ability to hide pages from the public and categorize them under the “private” category for any personal notes that one would keep in the same workspace as public notes.

Page settings

Pages have different settings the user can toy around with to have a better tailored experience for certain use cases.

• Style: the typeface of the page can be changed between three settings- the default sans-serif font which is the operating system default font (Segoe UI on Windows Vista or newer, San Francisco Pro on macOS 10.11+/iOS 9+, Roboto on Android 4+), a serif font (Lyon), and a monospace font (iA Writer Mono). These fonts are applied to the whole page; it is currently not possible to set some parts of the page to be a certain font and have other parts be another.
• Small text changes the font size from the default 16px to 14px.
• Full width changes the width of blocks to fill the entire page (this stretches as the Notion window is stretched), rather than having a fixed width. Pages with a lot of content are more easily shown with this setting on.
• Clicking customize page opens up another context menu with the options “Backlinks” and “Page comments”, allowing the user to change the way backlinks appear for databases with references and how comments on a page appear, respectively.
• Clicking lock page “locks” the page, making it read-only for reading rather than editing. It can be unlocked when the button is clicked again.
• Import: allows the user to import data into pages from other services or file formats:
  • Evernote
  • Trello
  • Asana
  • Confluence
  • Text/Markdown (.txt, .md…)
  • CSV (.csv…)
  • HTML (.html…)
  • Microsoft Word
  • Google Docs
  • Dropbox Paper
  • Quip
  • Workflowy
• Export: allows the user to export their pages into three file formats:
  • PDF (.pdf)
  • HTML (.html)
  • Markdown & CSV (.md, .csv; regular pages will be exported as Markdown and databases will be exported as CSV. However, since Notion pages have much more functionality than Markdown, not everything will be exported verbatim and with full functionality.)
• Move to: allows the user to move where the page is in the hierarchy. This can be as in the root directory or as a subpage. Although this option exists, it is usually easier to just drag and drop from the sidebar.

Other page properties

• Favoriting: Pages can be marked as favorites, pinning them to the top of the sidebar. This can be done by either right clicking the page in the sidebar, or clicking the three dots in the top right of a page.
• Sharing: It’s also possible to share pages, allowing other people to view them. The share dialog allows the user to either specify people to invite or share the page to the web, allowing anyone with the link to access the page.
• Updates: Notion keeps track of every change that is made to a page, keeping a log of what’s happening under the Updates tab. Every edit, change of permissions, invite, etc. is shown in the log with the user that made the change, the date, and the path to the page if the page in question is a subpage.
• Page history (Personal Pro plan required): Notion’s page history feature is different from the updates log. It shows the full page and what was edited every time the page is changed (as opposed to the updates which only shows the small section that was edited)- nearly identical to Google Docs’ version history feature.

At the bottom of the triple dot menu, Notion also displays the word count of the page and the last time it was edited.

Blocks

Blocks are the quite literal building blocks of Notion, which appear inside pages. They can take form as text, lists, tables, checkboxes, dividers, embeds, and much more, and provide a very user-friendly way to build pages. Additionally, blocks can be dragged around to change their order around pages for added ease of use.

Basic blocks

Pages initially start off with one empty block which can be typed in or transformed into another type. By clicking the handle on the left of the block, it’s possible to transform the block into a number of text-based types (so-called “basic blocks”):

• Plain text
• Headings 1, 2 and 3 (#, ##, and ### as shorthand)
• An entire page
• To-do list (checkbox)
• Bulleted (unordered) list (- as shorthand)
• Numbered (ordered) list (any number followed by a period as shorthand)
• Toggleable list (> as shorthand)
• Code (Start and end with ` as shorthand)
• Quote
• Callout
• Block equation
• Synced block

Non-text-based types like tables, Kanban boards and embeds can’t be realistically transformed from text, so they have to be created either by typing / or clicking the + on the left side of an empty block.

Inline blocks

Inline blocks, fittingly, can be created within other blocks instead of being created on a new line. Most of these blocks have shorthand that can be used.

• Mention: mention someone in the workspace so that they get a notification. Mentions start with an @ and show the user’s username in a light gray font.
• Page mention: page mentions do the same thing as regular mentions, except they don’t notify anyone because, well, pages can’t be notified. Page mentions have the page’s icon (if applicable), an arrow icon facing northeast (can be disabled), and the name of the page in bold. If clicked, the user will be taken to the page in question.
• Date/reminder: Adding an inline date/reminder block allows for mentioning of a date that will notify the setter of the notification on the date and time set. The date can be formatted relatively or absolutely; that is, both “9am tomorrow” and “June 5, 2022 6pm” will work as expected.

The above three inline blocks all make use of the @ symbol and are gray in color, so there could be confusion around a person named “June 15” or a page named “Tomorrow 9am”.

• Emoji: insert an emoji inline with text. Notion’s emoji use Twitter’s open-source Twemoji library, the same as sites like Twitter and Discord. Each emoji also has an alias that can be used to quickly type it when surrounded in colons- for example, the 🙂 emoji is known as “slightly smiling face”, so typing out :slightly smiling face: will bring it up (actually, since Notion searches the emoji set based what has been inputted so far, typing just :slight will probably bring it up pretty quickly. As a side note, Notion does not use the same emoji aliases as many popular services like GitHub, Slack, and Discord. Furthermore, emoji can also be copy-pasted into Notion, where they will be automatically converted to Twemoji.

• Inline equation: for any mathematical equations that are needed, Notion has KaTeX support, a library built to TeX specification with functionality similar to LaTeX.

Database blocks

Databases are a pretty refined feature available in Notion, allowing the storage of data in a spreadsheet form, and viewing it in an elegant way. There are several data types that can be used in Notion tables, separated by columns (as in each column is only allowed to have one data type). There are 18 data types in Notion, 11 of which are basic and 7 of which are advanced.

• Text: a simple string of text. Anything can be typed in a text cell, and there are no special functions for them.
• Number: a number that can be both an integer and a number with a decimal. There doesn’t seem to be a limit on the value of the number, but Notion will display the number in scientific notation if the number can’t fit in the cell when represented normally. Formulas can run arithmetic on them.
• Select: turns the cell into a dropdown box allowing for a specific value to be selected. Already existing values can be chosen in the dropdown, but typing something else in the input area will create a new select option. Dropdown values will have a random background color on creation, but this can be changed.
• Multi-select: exactly like a select cell, except multiple simultaneous values are allowed.

• Date: a selectable date. When clicked, Notion provides a date picker that allows the user to both type in a date and select one via a calendar. Cells with the date type can also have reminders, reminding the user at 9 AM (or the time set, if applicable) either on the day of the date set, a day before, 2 days before, or a week before; by default, it’s set to none. Dates can also be configured to be a range when the “End date” property is toggled, allowing for certain formulas to calculate the range between the two dates. Time can be set too, if one would need to be so precise for the cases of setting up a schedule, planner, or something else of that caliber. Setting the time zone that the date happens in is also possible, as well as how the date is formatted- in its full form, M/D/Y, D/M/Y, Y/M/D, or relatively.
• Person: a selectable user from the workspace. Anyone with access to the workspace can be referenced with a person typed cell. A person cell will display the name of the user selected along with their profile picture. Clicking on the cell does not do anything.

• Files & media: a selectable file or form of media. A file can be uploaded from a computer or phone or referenced via URL when using the embed option. Images and videos will show inside the cell rather than just being a plain URL. When clicked, they can be zoomed on to reveal their original size, as media inside of cells are most likely not. URLs embedded within these cells are clickable and will open in the default set browser. If needed, multiple files or forms of media can be added to a single cell, allowing for pictures, URLs, videos, and whatever else to share the same cell. The upload limit for files is 5MB unless the Personal Pro plan or above has been purchased.
• Checkbox: a simple checkbox that can be ticked or unticked. Text cannot exist next to it.
• URL: a text input for URLs. Any text can be entered, but if not in a URL format, it will function exactly like a text box. However, if in URL format, a link button will appear on the right side of the cell if hovered over, allowing for the user to open the link. This doesn’t guarantee that the link leads to a valid web page, as it only checks for the existence of a period and text on either side.
• Email: a text input for emails, pretty much identical to URL cells, except for emails instead of URLs. When a valid email is entered, an email button will appear on the right side of the cell when hovered over, redirecting the user to their mail client via a mailto link.
• Phone: a text input for phone numbers, pretty much identical to both URL and email cells, except for phone numbers. Pretty much anything in the box will allow the phone icon to show up which will redirect the user to their phone client or app if clicked.

• Formula: a Notion formula. Notion has its own formula system, allowing for cells in a database to be used to compute other values. While this guide will not go in depth with formulas, I will quickly list the components of a formula and how they are used. There are many other guides, such as this one that go much farther in. In the formula dialog, a list of the properties (columns) in the current database is on the left sidebar, referencing the cell in that column and the row selected. There are also:
  • Constants – constant values. There are currently four of them:
    • Number e (Euler’s number), approximately 2.71828, useful for calculating compound interest, radioactive decay, or other things concerning logarithms.
    • Number pi, or π, approximately 3.14159, useful for calculating the circumference of a circle or for many formulas in higher mathematics.
    • Boolean true.
    • Boolean false.
  • Operators – keywords that are used to compute with two or more values.
    • if, used to test a condition and return a chosen value if true or false. Syntax can be in the form of a ternary operator: boolean ? value : value or an Excel if statement: if(boolean, value, value).
    • add, used to add two numbers together or to concatenate text. Syntax can either be x + y or add(x, y) for addition of numbers, or "str" + "str2" or add("str", "str2") for concatenation of strings.
    • subtract, used to subtract a number from another. Syntax takes form as x - y or subtract(x, y), where y will be subtracted from x.
    • multiply, used to multiply numbers together. Syntax takes form as x * y or multiply(x, y). Strings cannot be duplicated by multiplying a string with a number.
    • divide, used to divide a dividend by a divisor. Syntax takes form as x / y or divide(x, y), where x is the dividend and y is the divisor.
    • pow, used to raise a number to an exponent. Syntax takes form as x ^ y or pow(x, y), where x is the base and y is the exponent.
    • mod, used to get the remainder of a dividend and divisor. Syntax takes form as x % y or mod(x, y), where the remainder of x / y will be returned.
    • unaryMinus, used to turn a number negative. Syntax takes form as -x or unaryMinus(x).
    • unaryPlus, used to turn a value of another type into a number, identical to the unary plus in many programming languages. Syntax takes form as + x or unaryPlus(x). Boolean false will be converted to 0, and true will be converted to 1. Strings comprising of numbers will be converted to numbers.
    • not, a representation of the logical NOT, returning the opposite of the value provided. Syntax takes form as not x or not(x), where the opposite of x will be returned.
    • and, a representation of the logical AND, returning true if both values provided are truthy, and false otherwise. Syntax takes form as x and y or and(x, y), where whether x and y are both truthy is returned.
    • or, a representation of the logical OR, returning true if at least one of the values is truthy, and false otherwise. Syntax takes form as x or y or or(x, y), where true is returned if either x is true, or y is.
    • equal, used to test if two values of the same type are equal, returning true if they are. It is not possible to test equality between types. Syntax takes form as x == y, or equal(x, y).
    • unequal, used to test if two values of the same type are not equal, returning false if they are, and true otherwise. Syntax takes form as x != y, or unequal(x, y).
    • larger, used for numeric, string, Boolean , or date comparison. true is returned if a number on the left side of the formula is greater than the other, and is also returned if a string’s value is larger. This seems to work for Latin alphabets for cross-comparison between upper-case letters and lower-case letters. true > false for Boolean comparison is the only combination that will return true. If a date is later than another, it is “larger” and true will be returned. Syntax takes form as x > y or larger(x, y).
    • largerEq, essentially the same as above, except true will be returned even if the values are equal, meaning that "yellow" >= "yellow" and 5 >= 5. Syntax takes form as x >= y or largerEq(x, y).
    • smaller, used for numeric, string, Boolean , or date comparison. true is returned if a number on the left side of the formula is lesser than the other, and is also returned if a string’s value is smaller by Unicode standard. Syntax takes form as x < y or smaller(x, y).
    • smallerEq, essentially the same as above, except true will be returned even if the values are equal, meaning that "windows" <= "windows" and 7 <= 7. Syntax takes form as x <= y or smallerEq(x, y).
  • Functions – special methods with a certain usage; usually to check for a certain value, create new values out of old ones, or serve functions that are otherwise impossible.
    • concat, used to concatenate two or more strings together, returning one string. Syntax takes form as either "x" + "y" + "z" or concat("x", "y", "z"), where the result is "xyz". Note that double quotes must be used, or else nothing will appear in the cells under the column. Also note that the shorthand notation is identical to the add function’s, as they serve the same purpose when strings are used.
    • join, used to glue strings together with a delimiter of choice. Syntax takes form as join("/", "6", "22", "1992"), where the output would be "6/22/1992". The delimiter in this case is /, and is used to glue 6, 22, and 1992 together by being put between them. Note that / neither appears at the beginning nor the end of the output string.
    • slice, used to take a substring from a string by slicing it with the provided indices. Syntax takes form as slice("Hot diggity dog", 4, 7), giving the result dig. Notion takes the position of the first index and puts a starting marker behind it, going through each character until it reaches the second index provided, at which point it stops behind it and returns what was run through between the two indexes. Please note that indexes start at 0, so in the above example, H would have index 0, o would have 1, t would have 2, and so on.
    • length, used to get the length of a string. Syntax takes form as length("string"), where the length of "string" would be returned (6).
    • format, used to format values of other data types as a string. Syntax takes form as format(x). Per Notion’s in-app support, format(42) would return the string “42”, format(true) would return "true", and format(now()) would return the current date in the format ddd M dd yyyy hh:mm:ss z. For example, if the time was January 1st, 1970 at 12 AM in CEST, the formula would return Thu Jan 1 01:00:00 GMT+01:00 (CEST).
    • toNumber, used to convert non-number values into numbers, if possible. Syntax takes form as toNumber(x), where x is the argument being converted to a string. So far, only text, numbers, Booleans, and dates are possible, and will only work if the value is able to be parsed- although, they won’t return an error if it doesn’t work; the cell will just be empty. Boolean true will be converted into 1, and Boolean false will be converted into 0. Dates will be converted into their Unix timestamp in milliseconds.
    • contains, used to check if a certain string contains a substring within it. Syntax takes form as contains(string, substring), where true will be returned if substring can be found inside string, and false otherwise. This only works with strings.
    • replace, used to replace the first instance of a substring with a text value. Syntax takes form as replace(x, y, z), where the first instance of string y will be replaced with string z in the value x. For instance, replace("hot dog man", " ", "_") will return hot-dog man, as the first instance of the space character was replaced by a hyphen, but the second one (and if applicable, all remaining ones) was left alone.
    • replaceAll, essentially the same as replace, but all instances of the substring are replaced instead of just the first instance. Syntax takes form as replaceAll(x, y, z).
    • test, to see if a string matches a regular expression. Syntax takes form as test(variable, regex), where the variable can be a number, string, or Boolean that will be matched with the regex. If the regex matches the variable, true will be returned, and false otherwise. For instance, test("hot dog", "[a-z]") will return true. For an in-depth guide on regular expressions, refer to this page on MDN.
    • empty, to see if a value is inherently “empty”. Syntax takes form as empty(value)m where value is being checked for “emptiness”. A value is seen as empty if it has no value: 0, false, and the empty string "" are some examples.
    • abs, which returns the absolute value of a specified number. Syntax takes form as abs(number), where the absolute value of number will be taken and returned.
    • cbrt, which returns the cube root of a specified number. Syntax takes form as cbrt(number), where the cube root of number will be taken.
    • ceil, which returns the ceiling of a specified number. Syntax takes form as ceil(number), where the ceiling of number is returned. Taking the ceiling is different from rounding, and will always return the integer equal to or above the specified number, regardless of how close the value is to the integer less than it. Inputting 7.8 will return 8, as will 7.5 and 7.1, although 7 will return 7.
    • exp, which raises e to a specified number. Syntax takes form as exp(x), where e^x is returned. Please note that exp is different from pow, which takes two arguments: a base and an exponent and is more commonly used. exp raises Euler’s number (~2.718) to the specified number.
    • floor, which returns the floor of a specified number. Syntax takes form as floor(number), where the floor of number is returned. Taking the floor is different from rounding, and is essentially the opposite of taking the ceiling, returning the integer equal to or lesser than the specified number. Inputting 2.5 will return 2, as will 2.1 and 2.9, although 2 will return 2.
    • ln, which returns the natural logarithm of a number. Syntax takes form as ln(x), where the natural log of x. Note that ln is equivalent to log(e) and that e^ln * x is equal to x.
    • log10, which returns the base 10 log of a number. Syntax takes form as log10(x), where log₁₀(x) (or more simply, log(x)) will be returned. For example, log10(10000) returns 4.
    • log2, which returns the base 2 log of a number. Syntax takes form as log2(x), where log₂(x) will be returned. For example, log2(256) returns 8.
    • max, which returns the maximum of a set of numbers. Syntax takes form as max(nums...), where nums... are the numbers that will be checked for a maximum. There is no minimum and, in practicality, no maximum amount of numbers to be checked, although Notion may slow down with larger data sets.
    • min, which returns the minimum of a set of numbers. Syntax takes form as min(nums...), where nums... are the numbers that will be checked for a minumum. There is no minimum and, in practicality, no maximum amount of numbers to be checked, although Notion may slow down with larger data sets.
    • round, which returns the number specified rounded to the nearest integer. Rounding is different from ceiling and flooring, rounding to whichever integer is closest rather than always up or down. Syntax takes form as round(x), where the value of x rounded to the nearest integer will be returned. 2.5, 2.7, and 2.9 will return 3, but 2.1, 2.4, and 2.49 will return 2.
    • sign, which returns the sign of a specified number, followed by 1. Syntax takes form as sign(x), where 1 will be returned if x is positive, -1 if x is negative, or 0 is x is 0.
    • sqrt, which returns the decimal square root of a number. Syntax takes form as sqrt(x), where the square root of x will be taken. Notion will round the result to 12 decimal places if x is not a perfect square. There will be no decimal if x is a perfect square. For example, sqrt(9) will return 3 and sqrt(13) will return 3.605551275464.
    • start, which returns the starting date in a date range. Syntax takes form as start(dr). If applicable, a selected date range dr, with a range from February 27th, 2019 to March 18th, 2021 will return the date February 27th, 2019.
    • end, which returns the ending date in a date range. Syntax takes form as end(dr). end is complementary to start, and will return the date March 18th, 2021 in the above situation.
    • now, which returns the current moment in time. Syntax takes form as now(); it takes no parameters. The current date and time (up to the hour and minute) in the local time zone will be displayed in the cell. The date is static and does not update. It reflects the time at which the formula was put into Notion.
    • timestamp, which returns the Unix timestamp in milliseconds. Syntax takes form as timestamp(date), where the Unix timestamp of date will be returned.
    • fromTimestamp, which returns a date from a Unix timestamp in milliseconds, exactly opposite from timestamp. Syntax takes form as fromTimestamp(timestamp), where timestamp is a 13-digit (although this will change in the year 2338) integer representing the amount of milliseconds since January 1st, 1970 at 12:00 AM UTC.
    • dateAdd, used to add a certain amount of units to a specified date. Syntax takes form as dateAdd(date, amount, unit), where date is the date amount units are going to be added to. unit can be one of the following in string format: milliseconds, seconds, minutes, hours, days, weeks, months, quarters, or years.
    • dateSubtract, used to subtract a certain amount of units from a specified date. Syntax takes form as dateSubtract(date, amount, unit) where date is the date amount units are going to be subtracted from. unit can be one of the units listed above.
    • dateBetween, used to find the amount of time between two specified dates. Syntax takes form as dateBetween(date, date2, unit), where the amount of time in units between date and date2 will be returned. The units available for use are listed above for dateAdd.
    • formatDate, used to format a date as a string using the moment.js standard time format. Syntax takes form as formatDate(date, format), where date is the date being converted and format is the format in which the string will be created. Moment.js’s official documentation has a format guide here.
    • minute, used to get the minute value from a specified date. Syntax takes form as minute(date), where the minute value from date will be returned. For example, if the specified date is 9/13/2021 10:19 PM PDT, 19 would be returned. If a minute value is not specified, 0 will be returned by default. Values range from 0 to 59.
    • hour, used to get the hour value from a specified date. Syntax takes form as hour(date), where the hour value from date will be returned. For example, if the specified date is 9/13/2021 10:19 PM PDT, 22 would be returned. If an hour value is not specified, 0 will be returned by default. Values range from 0 (12 AM) to 23 (11 PM).
    • day, used to get an integer representation of the day of week. Syntax takes form as day(date), where the day of week of date will be returned. Values range from 0 (Sunday) to 6 (Saturday). As an example, if the specified date is 9/13/2021 10:19 PM PDT, 1 would be returned.
    • date, used to get the day value from a specified date. Syntax takes form as day(date), where the day value from date will be returned. For example, if the specified date is 9/13/2021 10:19 PM PDT, 13 would be returned. A day value has to be specified in a date, so there is no default value. Values range from 1 to 31.
    • month, used to get an integer representation of the month. Syntax takes form as month(date), where the integer representation of the month of date is returned. Values range from 0 (January) to 11 (December), so the number returned is one less than the usual short two-digit date representation for month. As an example, if the specified date is 9/13/2021 10:19 PM PDT, 8 would be returned.
    • year, used to get the year value of a specified date. Syntax takes form as year(date), where the year value from date will be returned. For example, if the specified date is 9/13/2021 10:19 PM PDT, 2021 would be returned. A year value has to be specified in a date, so there is no default value.

• Relation: used to reference objects in other databases. If set to, a relation cell in one database is “linked” with those in another database- useful for creating connections between related data that are better separate for organization purposes. Relations can reference databases outside the current page as long as they are within the same workspace.
• Rollup: used with relations to aggregate data. Rollups allow for relations to have calculations applied to certain properties that exist within one of the databases in the relation. There are 17 different calculations that can be used in a rollup, with 8 “generic” calculations that can be used for any data types, 6 specifically for numbers. and 3 more for date values. Rollups can not be nested for safety reasons. A more detailed article on relations & rollups and how they can be used to effectively manage and aggregate data is available on the Notion website.
• Created time: a simple data type that shows the time of creation of the cell as a date.
• Created by: a simple data type that shows the user that created the cell as person data type.
• Last edited time: a simple data type that shows the time of last edit of the cell as a date.
• Last edited by: a simple data type that shows the user that last edited the cell as a person data type.

Similarities to Markdown

Notion’s pages bear a striking resemblance to Markdown for the simpler page elements, such as paragraphs, bulleted/numbered/toggleable/checkbox lists, horizontal rules, headers, and quotes. Most shorthand used for Markdown editing, such as surrounding with asterisks * to turn text bold, prefacing a line with - to start a bulleted list, or a number of hashtags # to denote a header is present in Notion. Of course, Markdown, being just a markup language, is by nature much simpler than Notion. Notion’s fancy database features, embeds, and integrations are unique and provide a lot of functionality for end users and serve a lot of different use cases. Regardless, the base part of Notion is very similar to Markdown’s syntax and look, so it’s a good idea to learn it to get a good grasp of how it works and improve efficiency.

As mentioned before, Notion grants the option of exporting a workspace to Markdown, which will be mostly compatible save for the more advanced blocks.

Similar Syntax

• **Text** will bold the text inside between the asterisks, returning Text.
• *Text* will italicize the text inside between the asterisks, returning Text.
• `Text` will format the text between the backticks as code in a monospace font.
• ~Text~ will strikethrough the text between the tildes, returning Text.

• Using an asterisk *, hyphen -, or plus sign + followed by a space will create a bulleted (unordered) list. These are interchangeable and can be used together in the same list.
• Using a number followed by a period and a space will create an numbered (ordered) list starting at the specified number.
• Using a pair of square brackets [] followed by a space will create a to-do list with interactive checkboxes that will cross out the text following them when clicked.
• Using a greater than sign > followed by a space will create a toggleable list.

• Using a singular hashtag # followed by a space and some text will create an H1 heading. ## will create an H2 heading and ### will create an H3 heading. While Markdown supports up to H6, Notion only supports H1, H2, and H3.

• Using a double quotation mark " followed by a space will create a quote block.

Dissimilar Syntax

There are some things, like images, that Notion has support for but doesn’t have the same syntax as Markdown for. Additionally, there are things like links that Notion only has partial Markdown support for. Markdown.org has a comprehensive article that lists all Notion-Markdown compatible elements.

Integrations & the public API

Notion is pretty well integrated with different services. Many different blocks allow for the embedding of certain content within pages, such as Google Drive files. The option to import notes from other services, such as Evernote, Trello, and Asana, is also offered. Clicking the “Import” button in the bottom left corner of a workspace shows the different services and file types that can be imported into Notion. This makes Notion pretty good for people who have notes from all over the place in different file formats that need to gather everything in one place and make everything uniform. A rundown on every service and file type supported is given in this article. Also, note that while there are many different services and file types that can be imported to Notion, they most likely won’t be able to be exported in the same way. There are only three ways to export a workspace— HTML, Markdown & CSV, or PDF (only for Enterprise subscribers), so be careful when deleting the original copies.

In addition to integrations with other services, Notion also has a public API for developers who want to create their own integrations. Databases, pages, blocks, and users in workspaces can be retrieved and edited via the standard HTTP protocol, conforming to REST conventions. I won’t go into detail about the API, but Notion has expansive documentation on their beta Developers website. If new to web programming with APIs, it’s best to get a basic understanding of how they work before trying to integrate with Notion, although there is no harm in experimenting.

Pricing

Notion, while free for personal use, does have other tiers users can upgrade to if they so desire. Currently, there are four plans: Personal (free), Personal Pro ($4 per month), Team ($8 per member per month), and Enterprise ($20 per member per month). While Notion has a full breakdown of their tiers and what features they provide in their app or on their website, here is a small overview of what changes between the tiers:

Personal

• Free, selected by default
• Unlimited blocks (back in my day, there was a limit of 1000 blocks for the free plan. Really toned down my Shift+Enter skills then.)
• 5 guests (guests are sort of preliminary members that can visit a single page (at a time) in a workspace but don’t have special permissions that the owner or other members of the workspace have. Notion’s documentation goes a little bit more in depth. This shouldn’t be a limitation if a workspace is completely for personal use.)
• 5 MB file upload limit (Every file uploaded to Notion’s server is limited to 5 MB. Since this limitation does not apply to files uploaded elsewhere, large images or videos can be uploaded to a hosting site or served via CDN.)
• No version history (Free plan users don’t have access to version history, a tool very similar to Google Docs’s version history allowing users to view and restore previous versions of pages.)
• Admin tools (free plan users can use the bulk export option to export workspaces, but both free plan and personal pro users don’t have access to the more enterprise-focused features like admin tools, permission groups, SSO, and SCIM that team and enterprise level users have.)
• No priority support (Notion prioritizes paid members in customer support, so if there’s a long line, prepare to wait or pay up.)

Personal Pro

• $4 a month when billed annually ($48 a year), $5 when billed monthly
• Unlimited blocks
• Unlimited guests
• Unlimited upload limit
• Version history for 30 days
• Same admin tools as offered in the free plan
• Priority support
• The main differences between Personal and Personal Pro are the amount of guests allowed on a workspace and the the file upload limit. If these are no objective, then it might be a good idea to stay on the free plan.)

Team

• $8 a month per person when billed annually ($96 a year), $10 when billed monthly (However, there is a free trial for this tier)
• Unlimited blocks
• Unlimited members (Anyone who is invited to a workspace has permissions that can be set by the owner. Unlike guests (who have limited access to the workspace), members are allowed to create and edit pages, can be separated into groups, can edit workspace-wide settings, edit members, and more (of course, if they have the permissions to).
• Unlimited guests
• Unlimited upload limit
• Version history for 30 days
• More expansive access to admin tools (as the Team plan is designed with collaboration in mind, administrators of a workspace have admin tools that allow them to set permissions of and edit members, restrict access to certain pages, and more.)
• Priority support
• The Team plan is really meant for multiple people; the major upgrades from the Personal Pro plan are all team-oriented (as the name suggests), and is pretty much a waste of money if only using Notion for personal use. Keep in mind that the Team plan is billed on a per-person basis, so the ever-scaling costs are something to be aware of.

Enterprise

• $20 a month per person when billed annually ($240 a year), $25 when billed monthly (Contact Notion’s sales department in order to purchase this plan)
• Unlimited blocks
• Unlimited members
• Unlimited guests
• Unlimited upload limit
• Unlimited version history
• All the admin tools that the Team plan has, plus advanced security tools, SAML & SSO, SCIM, and bulk PDF export
• Dedicated “success manager” for support
• Custom contracting/invoicing
• Ability to use new features earlier than everyone else

Which plan should I choose?

Of course, if using Notion for personal purposes only, either the free Personal plan or the cheap Personal Pro plan will suffice. Conversely, if using Notion for a team workspace, it’s imperative to get either the Team or Enterprise plans as it’s not possible to have multiple members in either one of the Personal plans (although I suppose it’s possible to hack together a pseudo-member solution with guests).

Separating between Personal & Personal Pro and Team & Enterprise is slightly harder, though, as the differences aren’t as obvious. If a high upload limit, the ability to have more than 5 guests, and version history are important, it might be a good idea to consider getting the Personal Pro plan. Otherwise, most people should be fine with the Personal free tier, which offers all of the base functionality.

Between the Team and Enterprise plans is a larger feature discrepancy as well as a larger price discrepancy- from $8 to $20 per person per month or $10 to $25 per person per month if paying annually. The Enterprise plan is a lot more hardy than the Team plan and appears to be designed for larger workplaces, with more advanced security features, admin tools, unlimited version history, and a tailored support team.

Another thing to note is Notion’s Education offerings- free Personal Pro for students and educators and 50% off Team for registered K-12 schools and higher education institutions.

Earning credit

Additionally, Notion gives opportunities to earn credit, which can go towards the payment of a plan. There are 6 of these to do, granting a total of $26 worth of credit, able to pay for 5 months of the Personal Pro plan, 2 months of the Team plan, or one month of the Enterprise plan. Most of the tasks can be done within a few minutes; three of them are logging into Notion from different platforms, one is importing notes from competitor Evernote, one is using the Chrome extension, and the last one is saving a link into Notion on either an iOS or Android device. Taking advantage of these credits and using them as a trial run of one of the paid plans is a good way to get a feel of them before paying.

Organization

A quote loosely attributed to Emmert Wolf, the saying that tools are only as good as the person wielding it remains true between lots of things in life. Working with Notion (or any software, really) is no exception. While Notion has a powerful feature set that is easy to use, it’s equally as easy to get lost in the organization part that comes with Notion (which also comes with, well, pretty much anything else.)

While the chore of organization on top of having to learn new software can be intimidating, it can be largely worth it in the end, especially if a workspace is used frequently— think of a student’s notes, a team’s project, or someone’s financial records. Simple things like nesting pages, adding icons, having a naming convention, consistently designing pages, and more will likely greatly improve the quality of life within a workspace— possibly even out of the workspace, too.

Nesting pages

Nesting pages, or putting pages inside pages, is one of the first things that comes to my mind when I think of organization. Pages that should be under a category with similar pages around them should have a structure that is reflected in Notion. In the sidebar, where each page is in relation to other ones is intuitive and resembles a file tree on a computer’s file explorer.

While it can help with organization, it can be a bit of a pain to expand every page every time access to a certain page is needed; Notion collapses all pages when the app or website is opened, which can get annoying when a workspace is large. However, do remember that pages can be marked as favorites, which are pinned to the top of the sidebar for easy access. Additionally, the search function can come in handy in this situation, too.

Using icons

Each page can have an icon, used in the sidebar and above the title in the page to represent the page. This can be easily set by clicking the “Add icon” button in a page without one, or by clicking the icon in a page that does. The dialog shown above will come up, allowing the user to choose an icon from the Twemoji emoji set, an image on their computer, or from a URL. The options to randomly set an icon and remove any icon are also present.

Icons can easily separate different pages from a sea of text in the sidebar. As previously shown, they can also be used to represent folders (Although this isn’t the only use. Using different emoji to represent something other than the page itself— perhaps a number or color to represent a value on a scale).

When uploading an image to be used as an icon, make sure that the resolution of the image is high enough to be seen clearly. Notion recommends a 280×280 image size, but higher-resolution displays will benefit from higher resolution images. Keep in mind that for free plan users, the maximum upload limit is 5MB (although an icon shouldn’t be this large… try compressing or reducing the canvas size of the file if possible).

Organizing blocks

Organization inside pages is just as important as the organization of pages themselves. It’s crucial to have readable notes or team-shared documents.

To make large portions of text readable, put descriptive headings where appropriate to make it easy to skip to sections and differentiate different parts of the text. Be sure to use header sizes appropriately as well— larger header sizes are for more broad, important topics, while subheadings should be used to denote smaller parts of each section. Bulleted lists and numbered lists should be used for their respective use cases when an array of items needs to be organized. Additionally, dividers can be used to separate sections on a more drastic level that headings can’t cover. Using headings and dividers in a consistent manner helps, too.

Arranding blocks side by side

Something that is possibly a little less known is the ability to put blocks next to each other, which is absent in a lot of other note apps that can allow for much more intuitive pages. Text next to photos instead of below or above like in the above picture can save space and look more appealing.

Any amount of blocks can be put next to each other; although, after a while, it’s probably best to just start on a new row, as the blocks get unreadably or unviewably small (especially for images, videos, and database components). It’s also possible to put more than one block in one of the columns of a row, as shown in the example above. With this, it’s pretty easy to put images next to headers and paragraphs for better visual comprehension.

Another thing that this makes possible is pseudo-tables. Since Notion automatically sets an equal amount of space for each block that is placed in a row next to each other, regardless of size, “pseudo-tables” can be made by making a large n by n table-like object, using any block as a cell. While this is hackier, it’s much more flexible than the currently existing database table, which can only contain certain text-based data types and images.

Using embeds

Embeds are also something in Notion that are not present in Markdown. As seen above, there are web bookmarks, which work similarly to the embeds on most social media sites (the OpenGraph data is taken from the website, so it looks the same as embeds from services like Facebook or Discord who use the standard) and can give visual appeal to a Notion page as it highlights a URL.

Actual HTML embeds can be put as well, using the generic “Embed” block. In the example above, links for a Spotify song and Google Maps location were used to give an embedded, interactive piece that the user can use instead of going to the website or service him or herself. Do remember that it is up to the service to create an embed for use― not all services will provide one.

In addition to the generic embeds, there are also service-specific ones. Google Drive files, Twitter posts, GitHub Gists, Google Maps locations, Figma files, Abstract projects, Invision projects, Framer prototypes, Whimsical boards, Miro boards, Sketch documents, Excalidraw whiteboards, Loom recordings, Typeform forms, CodePen pens, Replit repls, and PDFs are all able to be embedded using their respective blocks.

Embeds open up the portal of possibilities pretty much infinitely. Nearly anything imaginable can be used as an embed, so things like calendars, clocks, and weather widgets can be generated from a website and used on a Notion page, most especially a dashboard.

Using blocked and inline code

Code blocks and inline code are two ways to format code. The former is an actual block that grants the ability for syntax highlighting, copying, and captioning (along with the default block actions). Because of this, it should be used to showcase larger pieces of code. The latter is a format that can be applied to a string of text, making it more flexible in the sense that it is not a block on its own. Also because of this, inline code does not have syntax highlighting, does not have a copy button, and cannot be captioned. The inline code format should be used for super small pieces of code or single keywords that make sense in the context of a sentence.

Syntax highlighting― a feature that colors and styles a piece of code― is another thing that is missing in Markdown that Notion has support for. There are an immense amount of languages that are supported:

• ABAP
• Arduino
• bash
• BASIC
• C
• C++
• C#
• Clojure
• CoffeeScript
• CSS
• Dart
• Diff
• Docker
• Elixir
• Elm
• Erlang
• Flow
• Fortran
• F#
• Gherkin
• GLSL
• Go
• GraphQL
• Groovy
• Haskell
• HTML
• Java
• JavaScript
• JSON
• Julia
• Kotlin
• LaTeX
• Less
• Lisp
• LiveScript
• Lua
• Makefile
• Markdown
• Markup
• MATLAB
• Mermaid
• Nix
• Obj-C
• OCaml
• Pascal
• Perl
• PHP
• Plaintext
• Powershell
• Prolog
• Protobuf
• Python
• R
• Reason
• Ruby
• Rust
• Sass (.sass)
• Scala
• Scheme
• Sass (.scss)
• Shell
• SQL
• Swift
• TypeScript
• Visual Basic .NET
• Verilog
• VHDL
• Visual Basic
• WebAssembly
• XML
• YAML

Using database blocks

Database blocks— tables, Kanban boards, galleries, lists, calendars, and timelines— are the cornerstone of data organization in Notion. As explained before, data can be represented in the formats given by the database blocks. The question is more of when and how to use which block.

Tables are pretty self-explanatory. They look and work nearly the same as tables in other software like Google Docs, Microsoft Word, or other notetaking apps. However, the thing that separates Notion tables from the other, simpler ones is the fact that tables in Notion are very data-oriented. Since tables are linked to data, there exist data types that each column can be of, making them slightly more restrictive, but much more integrative and organizable. While more advanced than most tables found in word processors, they are not advanced as spreadsheets in software like Google Sheets or Microsoft Excel.

Kanban boards are a familiar component for people who have used software like Asana, Trello, or Jira. Essentially, they visualize work in a way that separates tasks based on completion status— each card (usually representative of a task in a project) is placed under one of several categories on a completion scale (in the above example’s case, Not started, In progress, and Completed). This makes it simple and easy to comprehend the overall status of a project and pick out tasks that need to be done. However, this is only a guideline for a specific use case. Cards can represent things other than tasks and can be separated on a scale that isn’t completion— perhaps difficulty, cost, or complexity.

Galleries are collections of pages that are organized as would be in an art gallery (or more aptly, an online image gallery)— in a row for easy access. Each page has a thumbnail that represents some of the content on the page: the first has a to-do list with two checkboxes and the third has an image of a bridge. Not every element can be displayed in the thumbnail, though. Page 2 has a web bookmark for Google.com, but the thumbnail is empty.

When clicked, the full page opens up and the requested content is there to be viewed in its entirety. This makes galleries good for collecting information that is larger than just a small piece of text or other information, providing functionality which tables and boards can’t.

Similar to galleries, lists can also collect pages, but in a shorter, more compact format. There aren’t any thumbnails for the pages— just the icon and name. For workspaces involving large amounts of pages, lists can often be much more suitable than galleries due to the compact index-like format in their nature— especially in cases where the content of the page is self-explanatory or not entirely useful in disambiguation between pages.

Calendars are used to organize and schedule time-based tasks. Notion makes it possible only to view a month’s worth of tasks at a time in a standard calendar format; to switch between months, use the arrows in the top right to increment or decrement the calendar by one month. Every task in the calendar above is, by default, a page with a date property and title, so more than just text can be set as an event in the calendar. When page content is edited, the icon will show next to the title of the page in the calendar.

The other time-related database block is the timeline. Needless to say, the timeline is a linear continuation of time that shows a card every “layer”, stretching from the set start date to the set end date. Like the calendar, each card is a page with a date property, showing the icon and title on the full block. However, a stark difference between the calendar and timeline is the time scale. The calendar is fixed to showing one month at a time (probably because it’s a calendar) while the timeline has 7 different scale units: in hours, days, weeks, bi-weeks, months, quarters, and years. Timelines, however, cannot be zoomed in or out.

For most applications, using a timeline is more suitable than using a calendar, as the timespan of tasks can be more easily compared and the zoom level is not confined to one month at a time. However, for specific scenarios in which a calendar format is preferred, it’s good to know that the option exists.

Linked databases & other views

Notion has the ability to link databases between pages, allowing for a reference copy of a database on one page that refers to the actual database on another. This makes it pretty easy to share information between pages while having the data in the database easily changeable.

Also, if applicable, databases can have additional views, allowing for a database of one type to be viewed as another; for example a list as a board, or a timeline as a calendar. However, unless the data fits the requirements to be viewed in the target view type, an incomplete database will be shown. For instance, a list full of pages without date types will not translate well to a timeline or a calendar— the blocks will be missing. The original, however, is still viewable and not affected by this.

Notion’s pitfalls

As good as Notion might seem on paper, nothing is perfect— certainly not software— and Notion is no exception. While it is possible that Notion seems like a revolutionary tool that has all the best features from other tools baked into one easy-to-use package, there are a lot of ways in which Notion falls short of expectation.

Lack of offline mode

Probably the largest complaint in the Notion community is the lack of an offline mode. The ability to work when a connection has dropped or a monthly data plan has run out or the train is passing through a forest where there is no connection or the McDonald’s WiFi is a tad too slow is quite valuable, especially for people who don’t have intensely strong or reliable internet (Comcast/Xfinity) all the time. All of Google’s office suite tools have offline capability, as do Notion’s competitors— Evernote supports offline notes that will sync to the cloud when an internet connection is available, and so do apps like Coda and Microsoft’s OneNote.

Notion “technically” has a makeshift “offline” “functionality” that will notify the user when the device has lost connection with a little badge at the top of the window or screen labeled “Offline”. However, this doesn’t save data to the local device and rather serves as a temporary indicator rather than a feature.

But because Notion is a fully online application, it’s quite difficult to implement an offline mode well— a seemingly simple change on the end user’s side can be the result of a massive backend infrastructural change. However, the Notion team has given multiple indicators in the past that they are working on bringing this feature as soon as possible.

Poor mobile experience

As technology advances in the world around us, the devices we use get more portable and easy to carry. The amount of people using tablets and phones instead of computers for work as they get more powerful is increasing, and the apps that we use for entertainment or productivity become more important as we rely more heavily on our mobile devices. Naturally, many companies and developers have created app versions of their previously non-mobile-optimized services to appeal to the ever-increasing demographic. However, making a mobile version of a website or program meant for a computer is not always easy and takes a lot of developing skill. Quite unfortunately, it doesn’t seem like Notion has quite passed the bar here.

The poor mobile experience of Notion on Android and iOS phones has also long been a complaint. While, at the very least, it looks like a UI meant for mobile users that took a bit of care into making, there is a lot to be improved on. It is essentially just a wrapper of the mobile website, so it’s not built with being an app in mind in its entirety.

The main thing that seems to be a problem is the speed or performance, which is capable of being insufferably slow at times. As mentioned earlier, Notion is strictly online and does not really cache anything to the device it’s being used on for longer than a restart, so every time a new page is navigated to that hasn’t been navigated to in a while, the entire page is loaded again, adding several seconds onto wait time per page accessed. This sluggishness is only exacerbated by any images or other media that are stored on the page (not media that is hosted elsewhere).

A secondary complaint is the lack of functionality on some parts of the mobile app. For example, on the desktop or web clients, any block can be moved with the drag of a cursor. However, on the mobile app, it’s not possible to move database blocks like tables and boards around. When long pressed on, they zoom in a bit but don’t budge. It’s also not possible to select or move more than one block at a time, making changes to large amounts of blocks stupidly time-consuming.

Speed

Probably the complaint that ties everything together is the unreliable speed of Notion that sometimes causes extreme sluggishness and long wait times for more complex or loaded workspaces. As mentioned previously before, Notion is a fully online application that does not store anything more than ephemeral cache on any device. Because of this, workspaces and their pages have to be loaded every single time a user wants to access them. Pages that have lots of images, videos, embeds, and other media, along with database components can increase the time to load by several seconds, adding up to hours lost over the course of a year waiting for pages to load.

While it is not easy for Notion to improve this situation overnight or even over a few weeks, it’s a little jarring to move from apps like Confluence or Trello or Google Docs— services that Notion claims they are replacing— moving from a fluid experience to one that loads for a noticeably annoying amount of time and feels like molasses.

Some have also reported that Notion seems to load faster on the web application and Apple OSs (macOS & iOS) than on Windows and Android clients. I have not personally seen this effect, but performance depends on a lot of factors.

Final verdict

From my experience, Notion has done pretty well at the thing it was designed to do— “replace” a lot of other more complicated applications or services and combine parts of each to create a single all-in-one-intentioned app that is a versatile tool for most of anyone to use. For a lot of my needs: keeping school notes, creating outlines of my projects, storing data in tables or boards, for example, Notion is ideal due to the simple but powerful interface.

Whether or not Notion is right for you, the consumer, is a different question. Moving from Google Keep to Evernote, then Evernote to OneNote, then multiple other note-taking apps over the course of multiple years before finally settling on Notion, it’s safe to say that Notion is something that I will stay on for a long time— at least until something even better comes out (let me know if you find anything). Initially, the page customizability and use of blocks (instead of the intricate but complex formatting system the Microsoft Office products use) was what reeled me in, but there have been many other things in addition to those that kept me in.

Notion is easy to recommend to people who don’t have super, super complex needs but are looking for something a little bit more than Google Keep or the pre-installed notes app on their phone. The simple interface is super easy to pick up, consistent, and elegant, so it can gravitate towards people looking for a powerful solution without coming off as too techy or intimidating.

For people who are a little more tech-savvy, Notion can be great, too. The extensive database feature, embeds, and page customizability come out to me as powerful features that can be great when utilized correctly. Additionally, the public API can bridge those gaps for people who like a little more integration between their apps.

Of course, it doesn’t hurt to try it out. There’s nothing to lose except for maybe the few minutes it took to sign up. I hope this article was informative in your decision to try out Notion. Thank you for reading!

Until next time…