SigNoz 2026 Review & Deployment Guide: Self‑Hosted OpenTelemetry Observability Platform on a $5 VPS

OpenTelemetry is great—until you realize you still need to build the backend, storage, UI, alerting, and scaling logic yourself. That’s where SigNoz steps in.

SigNoz is an open-source APM and observability platform built on OpenTelemetry standards, offering metrics, logs, and traces in a single UI. It’s gaining traction among homelabbers, startups, and small teams looking to avoid vendor lock-in and high cloud costs.

But does it still hold up in 2026? And can it realistically run on a $5/month VPS? Let’s break it down—both the review and a real-world deployment.

What Is SigNoz?#

SigNoz (pronounced “sign-us”) is a full-stack observability platform for distributed systems. It supports:

• Traces (via OpenTelemetry native)
• Metrics (Prometheus-compatible ingestion, native OTLP export)
• Logs (OTLP log ingestion, plus log parsing, filtering, and search)

It’s built with a clickhouse-backed storage layer, uses a Go-based collector, and ships a React frontend for dashboards and alerts. The architecture is modular: Collector → Ingestion → ClickHouse → Frontend.

SigNoz is MIT-licensed, actively developed (GitHub: SigNoz/signoz), and has a strong community around self-hosting.

SigNoz 2026: Features & Capabilities#

Core Features#

What’s New in 2026#

• ClickHouse 24+ support: Improved query performance, especially for high-cardinality data
• OTLP v1.0 compliance: Full OTLP 1.0 support for traces and metrics
• Log Pipelines UI: Drag-and-drop log processing pipelines (filter, parse, enrich)
• Reduced Memory Footprint: SigNoz Collector now runs with ~300MB RAM in light mode (vs ~600MB in 2024)
• Self-Hosted Alerting Improvements: More flexible alert thresholds, multi-condition rules

Performance on Low-End Hardware#

On a $5 VPS (e.g., 1 vCPU, 1GB RAM, 25GB SSD), SigNoz works—but with caveats.

• Baseline (no traffic): ~700MB RAM, 10–20% CPU idle
• With light app instrumentation (~10 req/s): ~1.1GB RAM, CPU spikes to 40–60%
• Without log ingestion: Significant RAM savings (~200MB less)
• ClickHouse compaction: Can cause temporary CPU spikes (every 10–15 mins)

For most small services or internal tools, SigNoz is usable—but avoid heavy log ingestion or high-cardinality tags.

Who Should Use SigNoz?#

✅ Startups & indie hackers building MVPs and want full observability without $100+/month SaaS costs
✅ Homelab enthusiasts running a few containers or VMs
✅ DevOps teams wanting to avoid vendor lock-in (e.g., no Datadog, New Relic)
✅ Engineers comfortable with self-hosting, Docker, and basic Linux admin
✅ Teams using OpenTelemetry SDKs (Go, Python, Node, Java, etc.)

If you’re already paying for cloud observability and want to reduce spend—SigNoz is worth testing.

When Not to Use SigNoz?#

❌ High-scale environments (>10k req/s): ClickHouse can become a bottleneck; consider SigNoz Cloud or managed solutions
❌ Teams without Linux/Docker experience: Self-hosting requires troubleshooting logs, config, storage
❌ Strict compliance needs: SigNoz doesn’t offer SOC2, HIPAA, or FedRAMP certifications (self-hosted)
❌ Teams needing native mobile/web APM at scale: SigNoz supports it, but instrumentation is manual and less mature than commercial tools
❌ Zero maintenance tolerance: You’ll handle upgrades, backups, scaling, and storage cleanup manually

SigNoz Deployment on a $5 VPS: Step‑By‑Step#

Let’s get practical. We’ll deploy SigNoz on a 1 vCPU, 1GB RAM, Ubuntu 22.04 VPS using Docker Compose.

Prerequisites#

• Ubuntu 22.04+ (or Debian 11+)
• Docker Engine ≥20, Docker Compose ≥2.20
• 2GB+ swap (critical for 1GB RAM VPS)
• Open ports: 4317 (OTLP gRPC), 4318 (OTLP HTTP), 8080 (frontend), 3306 (MySQL optional for alerts), 9090 (Prometheus optional)

# Update system
sudo apt update && sudo apt upgrade -y

# Install Docker & Compose
sudo apt install -y docker.io docker-compose-v2

# Create swap (if <2GB RAM)
sudo fallocate -l 2G /swapfile && sudo chmod 600 /swapfile && sudo mkswap /swapfile && sudo swapon /swapfile
echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

Step 1: Clone SigNoz Docker Setup#

SigNoz maintains a docker-setup repo with production-ready compose files.

git clone https://github.com/SigNoz/docker-setup.git
cd docker-setup

⚠️ Important: The default docker-compose.yaml assumes ≥4GB RAM. For 1GB RAM, we’ll use the light mode variant.

Step 2: Configure for Low-Memory VPS#

Edit docker-compose.yaml to reduce resource usage:

• Set OTEL_EXPORTER_OTLP_ENDPOINT to http://localhost:4317 (if ingesting locally)
• Reduce ClickHouse memory: Add clickhouse_server config override
• Disable optional services (e.g., otel-collector if using external collector)

Here’s a minimal docker-compose.lite.yaml:

version: '3.8'

services:
  frontend:
    image: signoz/frontend:v0.46.0
    restart: unless-stopped
    ports:
      - "3301:3301"
      - "8080:8080"
    environment:
      - CLICKHOUSE_HOST=clickhouse
      - QUERY_SERVICE_HOST=query-service
      - FRONTEND_PORT=3301
    depends_on:
      - clickhouse
      - query-service
    mem_limit: 256m
    memswap_limit: 512m
    cpus: 0.5

  query-service:
    image: signoz/query-service:v0.46.0
    restart: unless-stopped
    command:
      - "-clickhouse-url=tcp://clickhouse:9000"
      - "-port=8080"
      - "-clickhouse-database=signoz"
    ports:
      - "8080:8080"
    depends_on:
      - clickhouse
    mem_limit: 512m
    memswap_limit: 1024m
    cpus: 0.75

  clickhouse:
    image: clickhouse/clickhouse-server:24.8.5.15-alpine
    restart: unless-stopped
    ports:
      - "8123:8123"
      - "9000:9000"
      - "9009:9009"
    environment:
      - CLICKHOUSE_USER=signoz
      - CLICKHOUSE_PASSWORD=signoz123
      - CLICKHOUSE_DB=signoz
    volumes:
      - ./clickhouse-config.d:/etc/clickhouse-server/config.d:ro
      - ./clickhouse-storage:/var/lib/clickhouse
    mem_limit: 512m
    memswap_limit: 1024m
    cpus: 0.75

  alertmanager:
    image: signoz/alertmanager:0.26.0
    restart: unless-stopped
    ports:
      - "9093:9093"
    volumes:
      - ./alertmanager-data:/data
    depends_on:
      - query-service
    mem_limit: 256m
    memswap_limit: 512m
    cpus: 0.25

  otel-collector:
    image: signoz/otel-collector:0.88.0
    restart: unless-stopped
    command:
      - "--config=/etc/otel-collector-config.yaml"
    ports:
      - "4317:4317"   # OTLP gRPC
      - "4318:4318"   # OTLP HTTP
    volumes:
      - ./otel-collector-config.yaml:/etc/otel-collector-config.yaml
    depends_on:
      - clickhouse
      - alertmanager
    mem_limit: 256m
    memswap_limit: 512m
    cpus: 0.25

  # Optional: Prometheus for metric scraping (if not using OTLP)
  # Uncomment only if needed
  # prometheus:
  #   image: prom/prometheus:v2.48.0
  #   ports:
  #     - "9090:9090"
  #   mem_limit: 128m
  #   memswap_limit: 256m

Create clickhouse-config.d/max_memory_usage.xml:

<clickhouse>
  <profiles>
    <default>
      <max_memory_usage>300000000</max_memory_usage>
    </default>
  </profiles>
</clickhouse>

💡 Why this works: We limit memory per container, disable auto-compaction (via max_memory_usage), and avoid Prometheus to save RAM.

Step 3: Run SigNoz#

docker-compose -f docker-compose.lite.yaml up -d

Wait ~30 seconds, then visit http://<your-vps-ip>:8080. You’ll see the SigNoz UI.

Step 4: Ingest Data with OpenTelemetry SDKs#

Pick your language. Here’s a minimal example for Node.js:

npm install @opentelemetry/sdk-trace-base @opentelemetry/api @opentelemetry/exporter-trace-otlp-grpc

// app.ts
import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc';
import { registerInstrumentations } from '@opentelemetry/instrumentation';
import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';

const provider = new NodeTracerProvider();
provider.addSpanExporter(new OTLPTraceExporter({
  url: 'http://localhost:4317', // SigNoz collector
  concurrencyLimit: 10,
}));

provider.register();

// Instrument HTTP
registerInstrumentations({
  instrumentations: [new HttpInstrumentation()],
});

// Example span
const tracer = provider.getTracer('my-app');
tracer.startActiveSpan('example-operation', span => {
  console.log('Doing work...');
  span.end();
});

For Python, use opentelemetry-sdk and opentelemetry-exporter-otlp.

✅ Tip: Start with traces only. Logs and metrics increase storage and RAM significantly.

Step 5: Build Your First Dashboard#

1. Go to Traces → filter by service.name = "my-app"
2. Click a trace → see flame graph, span details
3. Go to Logs → search @level:ERROR
4. Go to Metrics → create a graph for http_server_requests
5. Click Save as Dashboard → name it My App Health

SigNoz dashboards auto-refresh and support time-range filters, templating, and drill-down.

Performance on a $5 VPS: Real Numbers#

I ran SigNoz on a DigitalOcean $5 VPS (1 vCPU, 1GB RAM) with:

• 2 Node.js services (~50 req/s total)
• Logs disabled (traces only)
• ClickHouse retention: 7 days
• No Prometheus

✅ Verdict: SigNoz is usable on a $5 VPS for low-to-moderate traffic apps—if you keep logs minimal and retention short.

Alternatives & Comparison#

SigNoz wins on integration simplicity and OpenTelemetry-first design. But if you already live in Grafana, Tempo+Mimir may integrate better.

FAQ: SigNoz on Low-End VPS#

Q1: Can I run SigNoz on a Raspberry Pi?
A: Yes—with light mode. A Pi 4 (4GB RAM) works well. Avoid logs and keep retention ≤3 days.

Q2: How do I reduce ClickHouse storage?
A: Use ALTER TABLE signoz_traces.logs DELETE WHERE timestamp < now() - INTERVAL 3 DAY manually, or set storage_policy in ClickHouse config.

Q3: Does SigNoz support alerting on traces?
A: Not natively yet. Alerts are metrics/logs-only. But you can use otel-collector to detect anomalies and send to webhook.

Q4: How do I back up SigNoz data?
A: ClickHouse stores data in /var/lib/clickhouse. Snapshot that directory (or use clickhouse-backup), and back up alertmanager config.

Q5: Can I upgrade SigNoz without downtime?
A: Yes—use docker-compose pull + docker-compose up -d. But check breaking changes in release notes first.

Final Thoughts#

SigNoz is one of the most practical open-source observability tools for small teams in 2026. It’s not perfect—clickhouse tuning can be finicky, and logs eat storage fast—but for traces and metrics, it’s excellent.

On a $5 VPS, it’s a viable self-hosted alternative to commercial APM tools if you’re willing to do basic maintenance. For homelabbers and indie developers, it’s a no-brainer.

If you’re evaluating observability tools, start with SigNoz—especially if you’re already using OpenTelemetry SDKs.

🔗 Try it: SigNoz GitHub | Docker Setup

— mahbuburriad.com