not3

not‑th.re is a modular, self‑hosted pastebin stack that decouples the UI, API, CLI and optional draw service into separate repositories. The architecture follows a classic RESTful micro‑service pattern, with the front‑end built on modern JavaScript tooling and the back‑end written in Go. The separation of concerns allows developers to host only the components they need—e.g., a lightweight API with an optional client‑side editor—or to replace the UI entirely with a custom single‑page application.

Technical Stack

• Backend: Go 1.22+, using the standard library’s net/http and Gorilla Mux for routing. The API is stateless, relying on a PostgreSQL database (or any SQL‑compatible store) for persistence of paste metadata and optional encryption keys.
• Database: PostgreSQL 14+ (default) with JSONB support for storing paste content, tags and metadata.
• Frontend: React (Vite) with the Monaco editor for syntax‑rich editing. The UI consumes the REST API via JSON over HTTPS and supports dark mode, client‑side encryption (AES‑256 GCM) and optional Excalidraw canvas integration.
• CLI & SDK: Node.js packages (@not3/cli and @not3/sdk) provide programmatic access to the API, enabling scripts or CI pipelines to create, fetch and delete pastes.
• Draw Service: A separate Go service exposing a WebSocket‑based drawing API, compatible with Excalidraw’s JSON format.

All services expose clear OpenAPI specifications and can be run behind a reverse proxy (NGINX, Traefik) or orchestrated with Docker Compose / Kubernetes.

Core Capabilities

• Paste CRUD: Create, read (public or private), update and delete pastes via HTTP endpoints (POST /paste, GET /paste/:id, etc.).
• Client‑Side Encryption: Optional AES‑256 GCM encryption performed entirely in the browser; only ciphertext is stored on the server.
• Syntax Highlighting: Monaco editor auto‑detects language or accepts explicit lang parameter; the UI serves highlighted HTML for preview.
• File Uploads: Binary blobs are stored alongside pastes; the API returns a secure download URL.
• Excalidraw Integration: Drawings can be embedded in a paste; the UI renders them using the official Excalidraw React component.
• Webhooks: The API can emit HTTP callbacks on paste creation or deletion, enabling downstream automation.

Deployment & Infrastructure

not‑th.re is designed for zero‑configuration self‑hosting:

• Containerization: Each component ships with a Dockerfile; official images are available on Docker Hub. A single docker-compose.yml can launch the API, UI and optional draw service with minimal effort.
• Scalability: The stateless API can be load‑balanced behind a CDN or reverse proxy. PostgreSQL can be replicated for read scaling, while the UI is purely static and served via any CDN.
• Resource Footprint: A minimal deployment (API + UI) consumes < 200 MiB of RAM and runs on a single CPU core, making it suitable for VPS or hobby hosting.
• High Availability: The API supports graceful shutdown and can be run behind a process manager (systemd, PM2).

Integration & Extensibility

• SDKs: The Node SDK exposes typed functions for paste operations, making it trivial to integrate into back‑end services or CLI tools.
• Webhooks & Callbacks: Developers can register endpoints to receive JSON payloads on paste events, enabling automated archival or CI job triggers.
• Plugin System: While the core does not ship a plugin framework, the modular architecture allows developers to fork and extend the UI or API. The draw service can be swapped for any WebSocket‑based drawing backend that follows the Excalidraw JSON spec.
• Custom Domains & TLS: The API and UI accept custom domain headers; integration with Let’s Encrypt via certbot is recommended for production.

Developer Experience

• Documentation: Each repository contains a docs/ folder with OpenAPI specs, usage examples and migration guides. The API’s Swagger UI is auto‑generated from the spec.
• Community: Active GitHub issues and PRs, with a clear contribution guide (CONTRIBUTING.md). The license (GNU AGPLv3) encourages open collaboration while protecting the project’s freedom.
• Configuration: Environment variables control database URLs, secret keys, and feature flags (e.g., enable drawing). No hard‑coded values mean the same image works across environments.

Use Cases

Advantages

• Performance: Go’s lightweight runtime and static binaries deliver