Operational

Operational.co is a lightweight, event‑driven monitoring platform designed for self‑hosted deployments. At its core, the application ingests JSON payloads representing critical product events—such as user sign‑ups, cron job completions, or webhook failures—and surfaces them in a real‑time timeline with push notifications to mobile and web clients. The service is built for rapid integration: a single line of JavaScript (or other SDKs) posts events to the /events/ingest endpoint, where they are persisted and routed to configured notification channels.

• Backend: Written in Go, leveraging the net/http standard library with a minimalistic router (chi). The choice of Go provides low‑latency, high concurrency suitable for handling bursts of event traffic.
• Messaging: Uses a lightweight in‑memory queue (nsq‑style pattern) to decouple ingestion from notification delivery, ensuring that the API remains responsive even under load.
• Database: PostgreSQL stores event metadata, user preferences, and webhook configurations. The schema is intentionally simple—events, subscriptions, and actions tables—to keep write amplification low.
• Frontend: React (Vite) delivers a SPA timeline. WebSocket (socket.io) keeps the UI in sync with incoming events.
• Notifications: Push via Firebase Cloud Messaging (FCM) for mobile, and email via SMTP. Webhooks are executed asynchronously using a worker pool.

• Event Ingestion API: POST /events/ingest accepts a JSON body with arbitrary attributes (name, avatar, etc.). The SDK abstracts this call.
• Action Buttons: Each event can include an actions array; clicking triggers outbound HTTP requests to user‑defined URLs.
• Workflow Chaining: Events can reference previous event IDs, enabling developers to model multi‑step processes and visualize dependencies.
• JSON Logging: Raw event payloads are stored verbatim, facilitating debugging of upstream services.
• Webhooks & API: Exposes a RESTful interface for creating, updating, and deleting event streams; supports authentication via API keys.

Operational.co ships as a Docker image (operational/ops:latest). The container expects environment variables for PostgreSQL connection, FCM credentials, and SMTP settings. For high availability, run multiple replicas behind a load balancer; the stateless API layer can scale horizontally. Persistent storage is achieved via a PostgreSQL cluster or managed database service. The lightweight Go binary keeps memory usage under 200 MiB, making it suitable for Kubernetes or bare‑metal servers.

• SDKs: Official JavaScript SDK (@operational.co/sdk) simplifies event posting. Community‑maintained clients exist for Python, Go, and Ruby.
• Webhooks: Developers can register arbitrary endpoints to receive event data or trigger internal workflows.
• Plugins: A minimal plugin interface allows adding custom processors (e.g., rate limiting, enrichment) by implementing a Go interface and loading them at runtime.
• Custom UI: The React frontend is open source; teams can fork and modify the timeline, add filters, or embed it in dashboards.

The SDK abstracts HTTP details, offering a clean API (ops.events.ingest({...})). Documentation is concise and hosted on the official site, with example code snippets and a “Playground” that lets developers paste JSON payloads directly into the browser. Community support is moderate; GitHub issues are actively maintained, and a Slack channel exists for real‑time questions. The project’s MIT license removes any licensing friction, encouraging internal use without cost.

1. Real‑time Incident Management – Capture critical errors from microservices and surface them on a mobile device to reduce MTTR.
2. Workflow Visibility – Chain events from user registration, email confirmation, and onboarding steps to audit process health.
3. Webhook Debugging – Log incoming webhook payloads and trigger retries or alerts when a downstream service fails.
4. A/B Testing – Emit events for feature flag toggles and monitor adoption rates in real time.

• Performance: Go’s concurrency model keeps ingestion latency below 10 ms even under high load.
• Flexibility: JSON‑based events mean no schema migrations are required for new data fields.
• Licensing: MIT license and self‑hosted nature eliminate vendor lock‑in and compliance concerns.
• Extensibility: Action buttons and workflow chaining provide a plug‑and‑play mechanism for building complex operational pipelines without writing additional code.
• Simplicity: Minimal configuration (API key, DB URL) and Docker support make onboarding fast for teams already using container orchestration.

Operational.co delivers a developer‑friendly, low‑overhead solution for turning arbitrary product events into actionable alerts and insights—ideal for teams that need immediate visibility without the bloat of full‑blown monitoring suites.