Stop Juggling 5 Monitoring Tools! Use highlight.io Instead

Your user just rage-quit your app. Again. You know it happened—your error tracker caught the exception. But why did they leave? What button did they click? What network request failed? What did they type into that form before everything exploded?

Here's the brutal truth: your current monitoring stack is a Frankenstein monster. You've got Sentry for errors, LogRocket for session replay, Datadog for logs, Jaeger for traces, and PagerDuty screaming at 3 AM. Five dashboards. Five bills. Five places to search when production breaks. And somehow, you still can't connect the dots between a frustrated click and a server-side panic.

What if I told you there's a single open-source platform that eliminates this chaos entirely? No more context-switching. No more vendor lock-in. No more wondering "what was the user actually doing?"

Meet highlight.io—the full-stack monitoring platform that top engineering teams are quietly adopting to replace their entire observability stack. And it's completely open source.

What is highlight.io?

highlight.io is an open-source, full-stack monitoring platform built by developers who were fed up with fragmented, expensive, and outdated observability tools. Founded by Jay Khatri and maintained by a passionate team including Vadim Korolik, Zane Mayberry, and Eric Thomas, highlight.io consolidates everything you need—session replay, error monitoring, logging, and distributed tracing—into one cohesive, modern solution.

The project exploded in popularity because it solves a problem every developer feels: observability shouldn't require a PhD in DevOps. While legacy tools force you to stitch together incompatible systems, highlight.io was architected from day one as a unified platform where every feature talks to every other feature.

Session replay isn't bolted on—it's embedded into error reports. Logs aren't siloed—they're linked to traces and user sessions. Traces don't exist in a vacuum—they surface the exact frontend clicks that triggered backend operations. This isn't marketing fluff. It's a fundamentally different approach to understanding your application's health.

The repository at github.com/highlight/highlight has become one of the fastest-growing open-source monitoring projects, with active development, a thriving Discord community, and enterprise-grade self-hosting options. Whether you're a solo developer shipping your first SaaS or a platform team managing microservices at scale, highlight.io meets you where you are.

And here's the kicker: you can self-host the entire platform in one Docker command or use their generous free tier. No credit card games. No "contact sales" traps. Just monitoring that works the way developers actually work.

Key Features That Make highlight.io Insane

DOM-Based Session Replay (Powered by rrweb)

Unlike pixel-based solutions that record videos, highlight.io uses rrweb to capture every DOM mutation, event, and interaction. The result? Crystal-clear replay at a fraction of the bandwidth cost. You see exactly what your user saw—including dynamic content, SPA navigation, and complex UI states.

Outgoing Network Request Inspection

Every fetch, XHR, and WebSocket appears in your session timeline with full request/response bodies. Debugging "it works on my machine" becomes trivial when you can see the exact API payload that failed in production.

Embedded Error Context

This is where highlight.io destroys competitors. Click any error, and you instantly see every session where it occurred. Click any session, and you see every error that user hit. The bidirectional linking eliminates the detective work that consumes hours of engineering time.

Powerful Search with Automatic Property Collection

Logs and traces aren't just text dumps. highlight.io automatically extracts structured properties, enabling complex queries without manual parsing. Search for user_id:12345 AND status:error across sessions, errors, logs, and traces simultaneously.

Customizable Alerting & Error Grouping

Tired of alert fatigue? Define smart grouping rules that collapse similar errors, and configure granular thresholds for when and where notifications fire. Integrate with Slack, Discord, PagerDuty, or your existing workflow.

Full SDK Ecosystem

From React to Python, Go to Ruby, highlight.io's SDKs drop into your stack with minimal configuration. The client-side snippet is literally a few lines of code.

Real-World Use Cases Where highlight.io Shines

1. The "Impossible" Frontend Bug

Your support team reports: "Users say the checkout button sometimes doesn't work." Traditional tools show you nothing—no errors in Sentry, no failed requests. With highlight.io, you filter sessions where users reached /checkout but didn't hit /success. Replay reveals the button is hidden by a race condition in your CSS-in-JS. Fixed in 20 minutes, not 2 weeks.

2. The Cascading Microservices Failure

A payment webhook fails intermittently. Your logs show a 500, but why? highlight.io's distributed tracing follows the request from the frontend click through your API gateway, payment service, and third-party provider. The trace surfaces a timeout at the exact moment a user clicked "Pay Now"—correlated with session replay showing their frustration as the spinner spun forever.

3. The "Not a Bug, It's UX" Revelation

Error rates look clean, but conversion is dropping. Session replay reveals users rage-clicking a disabled submit button because form validation errors appear below the fold. No traditional monitoring tool catches this. highlight.io's replay + error correlation exposes UX debt that analytics miss.

4. Onboarding New Engineers

Junior devs struggle to reproduce production issues locally. With highlight.io, you share a session URL and say: "Here's exactly what happened. Here's the network request. Here's the server trace." Onboarding time to productive debugging: cut by 70%.

Step-by-Step Installation & Setup Guide

Option 1: Hosted (Fastest Path)

Sign up free at app.highlight.io. Then add the client SDK to your frontend:

<!-- Add this snippet to your <head> -->
<script src="https://static.highlight.io/v7.5.0/index.js" type="module" crossorigin="anonymous"></script>
<script type="module">
  import { H } from 'https://static.highlight.io/v7.5.0/index.js';
  
  // Initialize with your project ID
  H.init('YOUR_PROJECT_ID', {
    environment: 'production',
    version: '1.0.0',
    networkRecording: {
      enabled: true,
      recordHeadersAndBody: true,
      urlBlocklist: [
        // Don't record sensitive endpoints
        'https://api.example.com/auth',
      ],
    },
  });
</script>

Option 2: Self-Hosted Hobby Instance

Want full data control? Deploy locally with Docker:

# Clone with all submodules (critical for dependencies)
git clone --recurse-submodules https://github.com/highlight/highlight
# For git < 2.13, use: git submodule update --init --recursive

# Enter the Docker directory and launch
cd docker && ./run-hobby.sh

System requirements: Minimum 8GB RAM, 4 CPUs, 64GB disk. The script handles everything—PostgreSQL, ClickHouse, Redis, and all services.

After startup, access at https://localhost. Login with any email and the ADMIN_PASSWORD from docker/.env.

⚠️ Hobby limits: <10k sessions and <50k errors/month. For production scale, see enterprise self-hosting docs.

Backend SDK Setup (Python Example)

import highlight_io
from highlight_io.integrations.flask import FlaskIntegration

# Initialize with your project ID and environment
H = highlight_io.H(
    "YOUR_PROJECT_ID",
    integrations=[FlaskIntegration()],
    instrument_logging=True,  # Auto-capture logs
)

# In your Flask app, errors and logs now stream automatically
@app.route('/api/checkout', methods=['POST'])
def checkout():
    try:
        process_payment(request.json)
    except PaymentError as e:
        # This error automatically links to the frontend session
        H.record_exception(e)
        raise

REAL Code Examples from the Repository

Let's dissect actual patterns from highlight.io's documentation and SDK source.

Example 1: Frontend Initialization with Privacy Controls

import { H } from 'highlight.run';

// Production-grade initialization with privacy safeguards
H.init('YOUR_PROJECT_ID', {
  environment: 'production',
  
  // Semantic versioning for error tracking
  version: '1.0.0',
  
  // Network recording with granular control
  networkRecording: {
    enabled: true,
    recordHeadersAndBody: true,
    
    // Block sensitive URLs from capture
    urlBlocklist: [
      'https://api.myapp.com/auth/refresh',
      'https://api.myapp.com/payment/*',
    ],
    
    // Redact specific headers
    headerBlocklist: ['authorization', 'cookie'],
  },
  
  // Privacy-first: mask sensitive DOM elements
  privacySetting: 'strict',
  maskAllInputs: true,
  maskAllText: false,  // Keep text for debugging, mask inputs
});

Why this matters: The urlBlocklist and headerBlocklist prevent credential leakage. The privacySetting tier lets you balance debugging power with compliance requirements (GDPR, CCPA). Without these controls, session replay becomes a liability.

Example 2: Custom Error Recording with Metadata

import { H } from 'highlight.run';

async function submitOrder(orderData) {
  try {
    const response = await fetch('/api/orders', {
      method: 'POST',
      body: JSON.stringify(orderData),
    });
    
    if (!response.ok) {
      throw new Error(`Order failed: ${response.status}`);
    }
    
    return response.json();
  } catch (error) {
    // Record with rich context for faster debugging
    H.consumeError(error, {
      // Tags for error grouping and alerting
      tags: { 
        component: 'checkout', 
        payment_method: orderData.paymentMethod,
      },
      
      // Structured metadata visible in error dashboard
      metadata: {
        order_value: orderData.total,
        item_count: orderData.items.length,
        user_tier: orderData.user.subscriptionTier,
      },
    });
    
    // Re-throw for your existing error handling
    throw error;
  }
}

The power move: consumeError doesn't just log—it enriches. The tags drive grouping rules; the metadata surfaces in dashboards. When you replay the associated session, you'll see the exact click that triggered this error, with all context pre-loaded.

Example 3: Self-Hosted Docker Environment Configuration

# From docker/.env - critical variables for hobby deployment

# Admin credentials for first login
ADMIN_PASSWORD=change-me-in-production-please

# Database configuration
POSTGRES_USER=highlight
POSTGRES_PASSWORD=postgres-password-here

# Object storage (sessions, replays)
OBJECT_STORAGE_FS=/tmp/highlight-data

# ClickHouse for high-performance analytics
CLICKHOUSE_ADDRESS=clickhouse:9000

# Redis for caching and queues
REDIS_EVENTS_STAGING_ENDPOINT=redis:6379

Production note: The hobby script sets these automatically, but for any real deployment, rotate all secrets and mount persistent volumes for OBJECT_STORAGE_FS. The default /tmp is ephemeral—your replays vanish on restart.

Example 4: Backend Trace Correlation (Go SDK Pattern)

package main

import (
    "context"
    "github.com/highlight/highlight/sdk/highlight-go"
    "github.com/highlight/highlight/sdk/highlight-go/middleware"
)

func main() {
    // Initialize with project ID
    highlight.Start(
        context.Background(),
        "YOUR_PROJECT_ID",
        highlight.WithServiceName("payment-service"),
        highlight.WithServiceVersion("2.1.0"),
    )
    defer highlight.Stop()
    
    // In your HTTP handler, traces auto-correlate with frontend sessions
    http.Handle("/api/pay", middleware.Middleware(
        http.HandlerFunc(handlePayment),
    ))
}

func handlePayment(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    
    // Custom spans for granular performance tracking
    span, ctx := highlight.StartTrace(ctx, "validate-payment")
    err := validatePayment(ctx, r)
    span.Finish(err)  // Auto-records error if non-nil
    
    // Logs automatically attach to current trace
    highlight.RecordLog(ctx, "payment_processed", map[string]interface{}{
        "amount":    99.99,
        "currency":  "USD",
        "method":    "card",
    })
}

The magic: middleware.Middleware extracts highlight's session context from incoming requests. Your backend trace automatically links to the frontend session that initiated it. When you view that trace in highlight.io, one click replays the user's journey.

Advanced Usage & Best Practices

1. Sampling Strategy for High-Traffic Apps

Don't record every session—sample intelligently. Record 100% of errors, 10% of successful checkouts, and 1% of general browsing. Use highlight.io's samplingStrategy configuration to implement this without code changes.

2. Source Map Upload for Production Debugging

Minified stack traces are useless. Automate source map uploads in your CI/CD:

# Add to your build pipeline
npx @highlight-run/sourcemap-uploader upload \
  --apiKey $HIGHLIGHT_API_KEY \
  --appVersion $(git rev-parse --short HEAD) \
  --path ./build/static/js

3. Alert Tuning to Prevent Fatigue

Start with high thresholds and tighten gradually. A rule that fires 50 times/day gets ignored. One that fires twice/month gets immediate attention. Use error grouping to collapse similar issues before they hit your pager.

4. Cross-Feature Dashboards

The real power emerges when you combine features. Create dashboards that show: error rate (errors) → affected sessions (replay) → server load (traces) → application logs. One view, complete context.

Comparison with Alternatives

The verdict: If you value cohesion over fragmentation and control over vendor lock-in, highlight.io isn't just an alternative—it's an upgrade.

FAQ

Is highlight.io really free?

Yes. The hosted version has a generous free tier, and the entire platform is open source under the Apache 2.0 license. Self-host for unlimited usage (with your own infrastructure costs).

How does session replay affect performance?

Minimal. DOM-based recording uses rrweb, which captures mutations rather than video frames. Typical overhead: <1% CPU, <100KB/session payload. Network recording adds negligible latency with urlBlocklist filtering.

Can I use highlight.io with React/Vue/Angular/Svelte?

Absolutely. The client SDK is framework-agnostic. Framework-specific wrappers exist for React (@highlight-run/react), Next.js, and more in the sdk directory.

What about mobile apps?

Currently web-focused, with React Native support in active development. Follow the GitHub repository for updates.

How do I migrate from Sentry/LogRocket?

Run both in parallel initially. highlight.io's SDKs can coexist—gradually shift as you validate the unified workflow. Error importers are on the roadmap.

Is my data secure in the hosted version?

highlight.io is SOC 2 Type II certified. All data is encrypted in transit and at rest. For maximum control, self-host entirely within your infrastructure.

Can I contribute to the project?

Yes! PRs are welcome. Check the contributor guidelines and join the Discord community for support.

Conclusion

The era of fragmented monitoring is ending. Engineers who waste hours context-switching between disconnected tools are losing to teams who see the complete picture in one place.

highlight.io isn't just another monitoring tool—it's a fundamental reimagining of how observability should work. Session replay, error monitoring, logging, and tracing aren't separate products. They're one cohesive system where every signal enriches every other signal.

The open-source model means you're never trapped. The self-hosting option means you're never exposed. The unified design means you're never guessing.

Stop juggling. Start understanding.

👉 Star the repository, deploy your first instance, and join the Discord community today. Your future self—debugging at 2 PM instead of 2 AM—will thank you.