Standard Notes

Standard Notes is a full‑stack, end‑to‑end encrypted note‑taking platform that places maximum emphasis on data sovereignty. The application is split into a web frontend (React‑based SPA compiled to static assets) and a microservice backend that runs on the user’s own server. The backend is responsible for authentication, sync, storage and background processing, while the frontend communicates exclusively over HTTPS with an API Gateway that routes requests to the appropriate service. This separation allows developers to host only the services they need, whether that be the full stack or just a self‑hosted sync server behind an existing web application.

Architecture & Technology Stack

The backend services expose a REST/GraphQL API protected by JWTs issued by the Auth service. All payloads are encrypted client‑side; the server only stores ciphertext, ensuring that even a compromised server cannot read user data. The sync engine uses vector clocks and conflict resolution to merge edits across devices, while the worker stack handles long‑running tasks such as generating revision histories or sending backup emails.

Core Capabilities & Developer APIs

• Sync API – POST /sync for bulk note uploads, GET /sync/changes for incremental pulls. The API is versioned and documented in Swagger/OpenAPI format.
• Auth API – /register, /login, /refresh endpoints; supports OAuth2 and SSO via custom providers.
• Webhooks – Developers can register callbacks for events such as note.created, note.deleted. Webhook payloads are signed with HMAC for verification.
• Plugin SDK – Plugins are built as Node modules that register themselves with the frontend via a JSON manifest. The SDK exposes hooks for editor extensions, custom note types, and UI overrides.
• CLI – A command‑line interface for server administration (e.g., snctl sync --backup), which communicates with the API over HTTPS.

All APIs are rate‑limited and support pagination, filtering, and bulk operations to keep bandwidth usage low for large deployments.

Deployment & Infrastructure

The official Docker images cover every microservice and can be orchestrated with docker‑compose or Helm charts for Kubernetes. The default Docker stack includes:

sn-auth
sn-sync
sn-worker
sn-api-gateway

Each container exposes a health endpoint (/healthz) and logs to stdout for integration with ELK or Loki stacks. For high availability, the Sync service can be scaled horizontally behind a load balancer; PostgreSQL is clustered via Patroni or Citus for read‑scales, while the object store can be any S3‑compatible service (MinIO, AWS S3, GCS). The API Gateway can be exposed behind a TLS termination proxy (NGINX or Traefik) to provide HTTPS for all client traffic.

Integration & Extensibility

Standard Notes encourages third‑party extensions. Developers can:

• Build Custom Editors (e.g., Markdown, LaTeX) that plug into the editor core.
• Create Enterprise Integrations by exposing a REST endpoint that consumes note data for reporting or analytics.
• Use Webhooks to trigger external workflows (e.g., send a note’s content to a CI pipeline).
• Publish extensions on the Marketplace where they can be installed with a single click.

The plugin system is sandboxed: each extension runs in an isolated iframe and communicates with the host via a well‑defined message bus, preventing accidental leakage of encryption keys.

Developer Experience

• Documentation – The public docs include a comprehensive API reference, plugin developer guide, and self‑hosting tutorial. Each microservice has its own README with environment variables, health checks, and troubleshooting tips.
• Community – A dedicated Discord channel, forum, and GitHub Discussions provide rapid feedback. The core team follows semantic versioning and publishes changelogs for every release.
• Configuration – Most services read configuration from environment variables (DATABASE_URL, JWT_SECRET, etc.). The Docker Compose stack ships with a .env.example that can be copied and edited.
• Testing – The repo contains unit tests in Rust/Go and integration tests that spin up the full stack via Docker Compose. CI pipelines automatically run these tests on every pull request.

Use Cases