Notabase: a linked note base for networked thinking

The idea is traversal, not storage

Notabase describes itself as a personal knowledge base for networked thinking, and the mechanism it proposes is linking. You connect knowledge and form ideas by linking notes together, and those links let you traverse your notes like webpages and find connections you would not have thought of otherwise.

The comparison the project offers is a personal Wikipedia for your brain that you can edit and browse as you like, and the claim is that it gets more powerful as you add notes. That is the argument for a graph shaped tool over a folder hierarchy: the value is in the edges, not the filing.

The inspiration list names Notion, Obsidian, Typora and Roam Research, so the family is clear. What Notabase does differently is stated in the features rather than in a marketing line, and the notable additions are page stacking, block references that auto-update, and a graph view.

The repository itself is a Next.js application. The scripts section of the package file shows next dev, next build and next start, and the pages/ and components/ directories plus an editor/ directory and a worker/ directory indicate a fairly conventional React application structure with the note editor pulled out as its own module.

Page stacking, backlinks and block references

Three features do the real work in this application.

Page stacking is the browse model, similar to Andy's working notes, where opening a note pushes it onto a stack rather than replacing the view, so you can move back through a chain of notes the way you would through browser history. For a tool whose premise is traversal, the navigation model matters as much as the editor.

Linked and unlinked references show you which other notes point at a given note. Unlinked references are the interesting half, since they surface notes that mention the title without formally linking to it. That is a cheap way to find connections you never explicitly made.

Block references let you embed a block of text from another note, and the embedded copy auto-updates when the original block changes. This is the one feature with a maintenance cost attached, because it creates a dependency between notes that you have to be able to see and undo.

Alongside those, notes are organised with links, tags and nested notes, and the graph view lets you analyse the knowledge graph as a shape rather than as a list. The d3-force, d3-drag, d3-zoom and d3-selection dependencies in the package file are what the graph view is built on.

Full text search is there as well, and fuse.js is the fuzzy matching library in the dependency list for it.

A WYSIWYG editor, a PWA and import/export

The editor is WYSIWYG with markdown support, so you read and edit formatted text rather than a raw source pane with a preview. The editor/ directory at the repository root holds that module, and the package file carries the editor related dependencies including is-hotkey for keyboard handling and @dnd-kit for the drag and drop sorting behind the nested note structure.

Installation as a Progressive Web App is listed as a feature, for faster loading and offline viewing. That is worth reading carefully because it interacts with the sync model. Your notes are synced to the cloud and can be accessed on any device, and the PWA gives you local caching for viewing. The next-pwa dependency handles the service worker side.

Import and export of notes is available at any time, which matters more for a self hosted setup than for a hosted one. It is the difference between a service you can leave and data you cannot.

Two smaller entries complete the picture. The application is instrumented with sentry for error reporting and posthog-js for analytics, and the analytics line is one of the things to consider before pointing a self hosted instance at production notes. The repository also carries a supabase/ directory, a cypress/ directory with its own config, and a scripts/ directory that holds the database schema and seed scripts.

Self hosting on Supabase, in four steps

The project states plainly that it is currently focused on the hosted experience, and that self hosting is possible. The steps are documented and specific.

First, Notabase uses Supabase as the backend for authentication, database and storage, so you need a Supabase account, or you can self host Supabase following their own documentation.

Second, you copy .env.local.example into .env.local and fill in three variables from your Supabase dashboard: NEXT_PUBLIC_SUPABASE_URL, NEXT_PUBLIC_SUPABASE_KEY and SUPABASE_SERVICE_KEY. The other environment variables are optional.

Third, you create the database tables by applying the full schema at scripts/schema.sql and the storage setup at scripts/storage-setup.sql.

Fourth, you install and run.

The three commands are `npm install`, then `npm run build`, then `npm start -- --port 3000`.

The application is then visible on http://localhost:3000, and for a development environment you run npm run dev instead.

That is a genuinely short setup, and the reason is that the application is a standard Next.js app talking to a managed backend. There is no separate backend to deploy.

The note cap lives in a database row

This is the part of the self hosting guide worth reading twice, because it tells you how the hosted and self hosted versions actually differ.

The hosted and self hosted versions share the same codebase, so by default there is a cap on the number of notes you can create. The documented way around it is to insert a new row in the subscriptions table for your user id, with pro in the plan_id column and active in the subscription_status column.

So the cap is not enforced in application code. It is a row in a table, checked by the same code path that checks a paid plan. That is a simple and effective design for a solo maintainer, since there is exactly one place to change, but it means the self hosted instance is running with a rule the author intended for the hosted service.

Two things follow. First, self hosting is genuinely free for personal use, since the check is a database value and not a licence. Second, the subscription table and the Stripe integration in the package file exist in your self hosted copy whether you want them or not.

The licence is AGPL-3.0, and the project states it is free for personal use and that commercial use requires contacting the author for a commercial licence. The package file records the licence as AGPL and the funding type as individual, with a GitHub Sponsors link, and the README names two commercial sponsors.

Testing, tooling and the state of the repository

There are two test layers, and they have different setup costs.

Unit tests run with npm run test, which is jest, with a jest:watch variant, a jest.config.js and a jest.setup.js, and fixtures and mocks directories at the repository root.

The Cypress end to end tests need more work. The first time setup is: install Docker and Docker Compose, run npx supabase init to initialise a Supabase project, and copy .env.test.example into .env.test with the variables filled in. To run them you start Docker, run npx supabase start, run NODE_ENV=test npm run dev, and then either npm run cy:open for the GUI runner or npm run cy:run for the command line.

That the end to end tests spin up a real local Supabase stack says something about the intent behind them. The whole application is a client of Supabase, so a mocked Supabase would test almost nothing.

The rest of the tooling is conventional: eslint with a .eslintrc.js, prettier with its own config, a typecheck script running tsc, husky for git hooks with a prepare script, a db:seed script, and a build analyzer behind an ANALYZE environment variable.

On project state, the repository is not archived and the last push was on 2026-07-17, and there are no GitHub releases, so the version is not tagged for consumers. The application version in the package file is 0.1.0 and the package is marked private.

Editorial conclusion

Adopt Notabase if you want a self hosted, linked note base where notes reference each other, backlinks are first class and the graph view is how you think, since the features are specific rather than generic. Do not adopt it expecting a polished product with a support commitment, because the project is a single maintainer with sponsorship as its funding and the last push was on 2026-07-17. Verify first that you are comfortable operating a Supabase project yourself, whether hosted or self-hosted, that you understand the AGPL terms and the fact that commercial use needs a separate licence from the author, and that you read the note cap before you import a large archive, since the limit is enforced through the subscriptions table.

Frequently asked questions

Official sources

1. churichard/notabase on GitHub
2. Issues
3. License: AGPL-3.0
4. Project website
5. README