Loading
Updated Jun 29, 2026 · 3 min read
A modular knowledge workspace built around persistent contextual nodes, extensible dashboards, scoped personalization, and scalable frontend architecture.
Synapcity is a long-term exploration into building a more contextual and composable productivity system.
The project began as a traditional note-taking application, but gradually evolved into a broader workspace platform focused on:
Rather than treating documents as isolated containers, Synapcity approaches knowledge as a connected system of contextual entities.
Notes, widgets, resources, metadata, and relationships are designed to exist within the specific context that created them.
Core Philosophy
Knowledge loses meaning when removed from its original context.
A comment attached to an entire document eventually becomes ambiguous.
A comment attached directly to the paragraph, idea, or concept that created it remains meaningful over time.
Most productivity platforms organize information around disconnected documents, pages, or tools.
As projects scale, information becomes increasingly fragmented:
Traditional workspace tools also tend to treat customization as a visual layer rather than an architectural capability.
I wanted to explore what happens when:
The application is built around several interconnected systems:
Together, these systems allow different parts of the workspace to remain independently customizable while still participating in a unified architecture.
Knowledge is organized hierarchically while remaining context-aware at the node level.
graph TD
Workspace[Workspace] --> Library[Library]
Library --> Notebook[Notebook]
Notebook --> Note[Note]
Note --> Node[Persistent Node]
Node --> Metadata[Contextual Metadata]
One of the most important architectural decisions in Synapcity was treating persistent editor nodes as primary entities instead of temporary editor structures.
Every heading, paragraph, and contextual block can own stable identifiers independent of Lexical runtime node keys.
This enables:
As the application evolved, theming requirements became significantly more complex than a traditional global dark/light mode.
Different scopes required independent customization:
The system eventually evolved toward hierarchical theme inheritance using semantic CSS variables and runtime synchronization through Zustand.
This approach dramatically reduced duplicated styling logic while improving consistency, scalability, and runtime performance.
We chose
What it cost
Synapcity’s dashboard system evolved from isolated widgets into a modular workspace infrastructure.
Widgets are treated as configurable workspace modules capable of:
This architectural shift transformed widgets from simple UI components into reusable infrastructure participants inside a larger workspace ecosystem.
Widgets evolved into composable infrastructure modules rather than isolated components.
The application uses Zustand extensively for scalable client-side state management.
Over time, the architecture evolved from feature-oriented stores toward reusable infrastructure patterns:
The project intentionally separates:
to reduce coupling and improve long-term maintainability.
Initial state architecture focused primarily on isolated feature stores and localized updates.
Repeated CRUD and synchronization patterns led to reusable abstractions and normalized entity structures.
The system evolved toward generic store factories, modular slices, and scoped synchronization patterns.
Some of the most significant architectural challenges included:
The project required balancing long-term extensibility with MVP development speed. Many systems were intentionally redesigned multiple times as architectural patterns became clearer.
Affected:
One of the biggest lessons from building Synapcity was realizing that most complexity did not come from rendering interfaces.
The real complexity emerged from preserving relationships, context, and extensibility as the application became increasingly modular.
Many systems initially appeared simple:
but became significantly more architectural as the platform evolved.
The project reinforced the importance of:
Most Important Realization
The goal is not simply to build another productivity application.
The goal is to build a contextual workspace system where knowledge, relationships, and workflows remain connected to the environment that created them.
Technical decisions and product lessons from this project.
Back to portfolio
View all projects →