highlight.io

Highlight.io is an open-source, full-stack monitoring platform that closes the gap between frontend user behavior and backend system performance. By combining session replay, error monitoring, structured logging, and distributed tracing into a single cohesive product, it eliminates the fragmented workflow of juggling Sentry, LogRocket, and Datadog separately.

Built on a TypeScript and Go monorepo, highlight.io ships with official SDKs for over fifteen languages and frameworks — from React and Next.js to Python, Go, Ruby, and Rust. Its Docker-based self-hosting makes deployment straightforward, while its hosted cloud tier at app.highlight.io offers a free plan that requires no infrastructure to manage.

The platform is designed around a simple philosophy: when a bug happens, you should be able to watch the exact session, see the error stack trace, pull up the correlated backend logs, and trace the slow request — all without leaving the same screen. This tight integration of signals is what differentiates highlight.io from point solutions that require manual correlation across dashboards.

The project is actively maintained with regular Docker releases, an engaged Discord community, and a public roadmap. Both a hobbyist single-node deployment and a production-grade enterprise cluster are supported, giving teams flexibility to start free and scale as needed.

What You Get

• High-fidelity DOM-based Session Replay - Records every DOM mutation, user interaction, and network request using rrweb, enabling pixel-accurate reproduction of exactly what a user saw and did when a bug occurred.
• Error Monitoring with Customizable Grouping - Automatically captures unhandled exceptions and manual error reports, then groups them using configurable rules so teams can distinguish signal from noise across high-volume applications.
• Structured Log Ingestion and Search - Collects logs from any backend SDK with automatic property extraction, then surfaces them in a searchable interface with direct links to associated sessions and errors.
• Distributed Tracing with Automatic Context Propagation - Traces requests across service boundaries using OTLP-compatible instrumentation, with trace context automatically threaded through Kafka, HTTP, and gRPC calls.
• Embedded Session Replay in Every View - Whether you are looking at an error group, a log entry, or a trace span, a one-click replay of the associated user session is always available in the same panel.
• SDK Ecosystem for 15+ Environments - Official instrumentation packages for React, Next.js, Node.js, Python, Go, Ruby, Rust, Elixir, PHP, .NET, Java, Cloudflare Workers, Remix, and more, with consistent APIs across all.
• Customizable Alerting and Notifications - Define threshold-based or anomaly-based alerts and route them to Slack, PagerDuty, email, or custom webhooks with configurable frequency and suppression rules.
• SQL-based Metrics and Dashboards - Build custom dashboards using a SQL editor that queries your ingested telemetry, with support for grouping, bucketing, and visualizing trends over time.
• Session Comments and Team Collaboration - Annotate specific moments in a session replay to communicate bug context directly to teammates without needing to export screenshots or write long reproduction steps.

Common Use Cases

• Diagnosing a customer-reported UI bug - A support engineer pastes a session ID from the user report into highlight.io, watches the exact replay, sees the console error and failed network request that caused it, and hands the backend log trace to the on-call engineer in one click.
• Post-deploy regression triage - After a release, an engineer sets an alert on new error rates exceeding a baseline; when it fires they drill into the error group, see which session first triggered it, and replay the failing interaction to confirm the regression.
• Microservice performance investigation - A backend team uses distributed tracing to identify that a slow checkout endpoint traces to a downstream inventory service making redundant database queries, confirmed by correlated logs showing the repeated SQL calls.
• Reducing MTTR during on-call incidents - An on-call engineer pages on a spike in 500 errors, opens the trace for a failing request, sees the associated backend log lines and the frontend session of an affected user, and resolves the issue without needing to SSH into production servers.
• Self-hosted compliance deployment - A fintech team running highlight.io on their own Kubernetes cluster ensures that no session data ever leaves their VPC, meeting data residency requirements while still having full-stack observability.

Under The Hood

Architecture Highlight.io is structured as a large Yarn Workspace monorepo coordinated by Turborepo, containing over twenty interconnected packages spanning a Go backend, a React/Next.js frontend, a suite of framework-specific SDKs, a forked rrweb recorder, and shared tooling. The backend follows a layered architecture with clearly separated concerns: an ANTLR-generated grammar handles search query parsing, dedicated GraphQL schemas serve public and private APIs via separate route handlers, and Kafka decouples high-throughput session ingestion from the processing workers. The frontend and backend communicate exclusively through GraphQL, keeping the two halves independently deployable. The enterprise feature gate is implemented as a runtime license check in a separate package rather than a compile-time flag, allowing the same binary to run in both open and enterprise modes.

Tech Stack The backend is written in Go and uses gqlgen for GraphQL code generation, chi for HTTP routing, PostgreSQL via GORM for relational data, ClickHouse for time-series telemetry storage, Redis for caching and pub-sub, and Kafka for durable session payload queuing. Session replay assets are stored in S3-compatible object storage with optional AWS Lambda for server-side rendering of replay thumbnails. The frontend is a React application using Apollo Client for GraphQL, Vanilla Extract for type-safe CSS-in-TypeScript styling, and Vite for local development. The SDK layer spans TypeScript, Go, Python, Ruby, Rust, Java, PHP, Elixir, and .NET, each wrapping the same OTLP-compatible telemetry primitives. Infrastructure is fully Dockerized with Compose files for hobby, development, and enterprise cluster topologies.

Code Quality The codebase maintains comprehensive test coverage across both the Go backend and TypeScript frontend. The backend has Go test files for workers, Kafka queue handling, pricing logic, store operations, and ANTLR parser correctness. The frontend uses Vitest for unit tests on utilities and hooks, while Cypress provides end-to-end test coverage through a dedicated test suite. Error handling in the Go backend follows explicit error propagation patterns with structured logging via logrus and span-based tracing of every meaningful operation. TypeScript code relies on generated types from GraphQL codegen and strict TypeScript configuration, which keeps the frontend type-safe against API changes. ESLint and Prettier enforce consistent style across the JavaScript ecosystem.

What Makes It Unique Highlight.io’s core differentiator is the seamless correlation between frontend sessions and backend telemetry without requiring any manual linking. The rrweb fork adds support for recording Shadow DOM, Canvas, and WebGL elements — surfaces that most session replay tools silently drop. The custom ANTLR search grammar gives users a consistent, powerful query language across sessions, errors, logs, and traces rather than per-product search boxes. The dual deployment model — a single-command hobby instance capped at modest volume and a horizontally scalable enterprise cluster with license-gated features — lets the product serve solo developers and large engineering teams from the same open-source codebase.

Self-Hosting

Highlight.io uses a split license model. The majority of the codebase is released under Apache 2.0, which allows commercial use, modification, and distribution without copyleft obligations. However, code inside the directory is governed by a proprietary Highlight Enterprise License that requires a paid subscription agreement for production use. Self-hosters running the open-source hobby or community editions are not affected by this restriction, but any team that needs enterprise-tier features — SSO, advanced access controls, or priority support SLAs — must obtain a license from Highlight Inc.

Running highlight.io yourself requires a meaningful infrastructure commitment. The hobby deployment targets a single Linux host with Docker Compose and recommends at least 8 GB of RAM, 4 CPU cores, and 64 GB of disk space; it is documented as suitable for fewer than 10,000 sessions and 50,000 errors per month. A production-grade self-hosted cluster adds ClickHouse, Kafka with ZooKeeper, Redis, and object storage such as S3 or a compatible alternative. Your team is entirely responsible for provisioning, patching, scaling, and backing up each of these components. The deployment is defined in layered Docker Compose files, and the project provides shell scripts to bring services up, but orchestration on Kubernetes or other platforms requires additional work beyond what is officially documented.

The hosted cloud at app.highlight.io offers a free tier and removes essentially all operational burden. Teams choosing cloud over self-hosting gain automatic upgrades, managed ClickHouse and Kafka, built-in high availability, and direct access to the Highlight team for support. The enterprise self-hosted path can include hands-on assistance from the Highlight team, but operational responsibility remains with the deploying organization. If your team lacks DevOps capacity for a multi-service stack or needs guaranteed uptime SLAs, the hosted product is the more pragmatic choice; self-hosting makes the most sense when data residency, network isolation, or cost predictability at high volumes are non-negotiable.