2026 · completed · web
Noted
Noted is an AI-powered collaborative study and knowledge-management platform that combines rich note-taking, real-time editing, AI assistance, flashcards, quizzes, file management, and productivity tools in one workspace.
overview
Noted transforms traditional note-taking into a complete study and knowledge-management system. Users can create structured notes using a rich-text block editor, organize content through folders and tags, collaborate with others in real time, and generate summaries, quizzes, flashcards, translations, explanations, and flowcharts using AI.
The platform uses TipTap for rich-text editing and Y.js CRDTs for conflict-free collaborative editing. Socket.io manages real-time communication, cursor presence, and document synchronization, while PostgreSQL stores users, pages, folders, collaborators, subscriptions, and learning data.
Noted also includes study-focused features such as spaced-repetition flashcards based on the SM-2 algorithm, quizzes with instant feedback, and a floating Pomodoro timer. Files such as PDFs, images, and documents can be uploaded and managed through an integrated file library.
AI requests are routed through a provider layer supporting Groq, OpenAI, and local Ollama models. The system validates usage limits, prepares note context, builds task-specific prompts, streams responses, and allows generated output to be inserted directly into notes.
the problem
at a glance
architecture
sequenceDiagram
actor User
participant UI as Next.js Frontend
participant API as API Layer
participant Auth as Better Auth
participant WS as Socket.io + Y.js
participant AI as AI Provider Layer
participant DB as PostgreSQL
participant Redis as Redis
participant Storage as S3 / R2
participant Stripe as Stripe
User->>UI: Open dashboard or note
UI->>Auth: Validate session
Auth-->>UI: Return authenticated user
UI->>API: Request notes and folders
API->>DB: Fetch user content
DB-->>API: Return notes and folders
API-->>UI: Display workspace
User->>UI: Open a collaborative note
UI->>WS: Join document room
WS->>DB: Load saved document state
DB-->>WS: Return Y.js state
WS-->>UI: Synchronize note
User->>UI: Edit note
UI->>WS: Send document update
WS->>Redis: Publish update and presence
WS->>DB: Persist document state
WS-->>UI: Broadcast synchronized changes
User->>UI: Use an AI action
UI->>API: Send note context and mode
API->>DB: Check usage limits
API->>AI: Generate response
AI-->>API: Stream AI output
API-->>UI: Display generated content
API->>DB: Track AI usage
User->>UI: Upload a file
UI->>API: Send file
API->>Storage: Store uploaded file
Storage-->>API: Return file reference
API->>DB: Save file metadata
API-->>UI: Add file to library
User->>UI: Upgrade subscription
UI->>API: Create checkout session
API->>Stripe: Start payment flow
Stripe-->>API: Return checkout URL
API-->>UI: Redirect to checkoutchallenges
- 01
Building Conflict-Free Collaboration
Multiple users editing the same note could create overwritten content or inconsistent document states. How I tackled it: I used Y.js CRDTs to merge concurrent changes and Socket.io to broadcast resolved updates and presence information.
- 02
Synchronizing Editor State with Persistent Storage
Collaborative state needed to remain responsive in memory while also surviving server restarts. How I tackled it: I synchronized Y.js updates through the WebSocket server and periodically persisted the serialized document state in PostgreSQL.
- 03
Managing a Large Feature Set
Notes, folders, collaboration, AI, files, flashcards, quizzes, billing, and productivity tools created a complex application structure. How I tackled it: I separated the platform into focused modules, components, contexts, API routes, and domain-specific services.
- 04
Generating Reliable AI Output
Different AI actions required different prompts, output formats, context limits, and usage policies. How I tackled it: I created an AI pipeline that validates quota, truncates context, selects an appropriate prompt and model, streams output, and records usage.
- 05
Implementing Spaced Repetition
Flashcards needed dynamic review intervals rather than simple completed or incomplete states. How I tackled it: I implemented the SM-2 algorithm using user grades, ease factors, previous intervals, and calculated next-review dates.