Slippod's Simple Architecture

3 min

Slippod is a simple, privacy-first note-taking app designed specifically for your desktop. It comes with a dead simple architecture to store all your notes locally in one SQLite file. It allows you to own your data and can back up all your notes easily.

Our engineer Yafu wrote an article about its simple architecture to share the thinking behind how we designed it.


No note-taking app is perfect. Apps like Evernote, Notion, Obsidian, and Logseq each have their own advantages but can be complex and packed with unnecessary features. Finding the ideal app is impossible, and transferring data between apps is challenging due to differing data formats. Even with promises from providers not to misuse your data, it’s uncertain how it might be used for commercial purposes.

For simplicity, you don’t need any app to store your written text. You can organize your notes in local files and folders, but searching for specific notes or moving them to another computer might be tricky.

This article proposes a simple architecture to manage your notes. If you’re familiar with programming, this simple architecture allows you to quickly create a note-taking app.

The most essential principle for any note-taking app is storing notes in a manageable, movable, and backup-friendly single file.

SQLite provides an effective solution for managing notes with features like a unified, standalone file, comprehensive SQL support, full-text search, and easy data organization. This removes the need for a server, as all data is locally stored. SQLite’s compatibility with different tools, independence from client applications, and easy integration offer flexibility. Thus, even if the note-taking app is unavailable, your data remains accessible and portable, ensuring constant access to your information.

With SQLite, your notes can be stored in a table with only two fields, much like Excel.

+----+-----------------------------+
| id |            note             |
+----+-----------------------------+
|  1 | note 1, some recording text |
+----+-----------------------------+

The Zettelkasten method is an effective way to write notes and grow your knowledge. One of its principles is that notes should be densely linked to each other. We can easily achieve this using @id mentions in notes.

+----+-----------------------------------------------------+
| id |                         note                        |
+----+-----------------------------------------------------+
|  1 | note 1, id 1, some recording text                   |
|  2 | note 2, id 2. we can link to note @1                |
+----+-----------------------------------------------------+

Linking to a note is as simple as typing @ followed by the ID of the note you want to link. To make linking to notes user-friendly, we can leverage SQLite’s full-text search by allowing users to first type @, then a keyword to find the note they want to link to.

Notes naturally form into different topics or themes. One standard approach to organize notes into topics or themes is tagging. In our architecture, we can simply implement tagging by allowing users to add a tag by simply typing #tag_name inside the note.

+----+-----------------------------------------------------+
| id |                         note                        |
+----+-----------------------------------------------------+
|  1 | note 1, id 1, some recording text                   |
|  2 | note 2, id 2. we can link to note @1                |
|  3 | note 3, id 3. we can tag it to #tag_name            |
+----+-----------------------------------------------------+

Just like @id mentions, we can allow users to first type #, then a keyword to find the tag they intend to add to the note.

To enable complex note formatting, we can use Markdown, which is popular and easy to use. Markdown fits nicely with our architecture since all the Markdown syntax can easily be parsed and rendered in HTML.

We can use Markdown for note presentation because it’s popular and easy to use. This lets us use existing libraries instead of making our own parser, saving time and aligning with standards for easier note creation and formatting.

So far, our underlying architecture is set to allow you to store your notes in a movable and backup-friendly single file with all the necessary note-taking features you need.

To actually build the UI on top of the underlying architecture, we have a broad range of choices. You can choose whatever frameworks and technologies based on your skill sets and preferences.

See? It’s not that hard to build a modern note-taking app.

If you’d like to see the simplicity of this architecture, check out our Slippod app. If you're interested in building the app yourself, the full SQL schema is available here.