The standard observability stack:
Grafana + Loki + Tempo + Prometheus. Four services to deploy, four configs to learn, dashboards to set up before you see a single trace.

What I actually needed:
One place to see traces, logs, and metrics from my services.

What I built:
One container. docker compose up. Done.

I work with .NET microservices and at some point I went through the full Grafana setup. And look, it works fine, it's a solid stack. But for what I needed it was way too much. I spent more time configuring things than actually looking at my data. The .NET Aspire dashboard is on the other end: you get a nice UI, but nothing is persisted. Close the browser and everything's gone. No customization either.

So I built something in between.

What it is

OtlpDashboard is a single container that receives OpenTelemetry data and stores it. It speaks standard OTLP on port 4317 (gRPC) and 4318 (HTTP/Protobuf). If your app already exports telemetry, you just point it here. No collector needed (works behind one too if you already have it).

Storage is SQLite by default, so zero config, just a file. You can switch to PostgreSQL or SQL Server if you want.

The frontend is a Vue 3 / Nuxt 4 SPA served on the same port. You get a grid of widgets you can customize: stat cards, line charts, sparklines, gauges, heatmaps, log streams, trace viewers, and a few more. Auth is on by default.

How AI helped me ship this in under a month

I want to be upfront about this. I used Claude Code a lot, especially for the frontend. I'm a backend dev. I know .NET, EF Core, gRPC. But Vue and Nuxt? Not really my thing. Without Claude Code I would have spent days stuck on CSS and component wiring. Instead I could focus on what I actually care about: the OTLP ingestion, the storage layer, how widgets work.

All the architecture and decisions are mine. The AI did the typing.

And honestly, I think that's the best use of these tools right now if you're a solo dev. They don't replace you. They cover the parts where you're slow, so you can ship something that would normally need a small team.

Some stuff I like about how it turned out

You can install widget packs from Git repos. There's a pack.json that bundles widgets and dashboards together, so if you have a team you can share a curated setup.

There's also a spec engine for building custom widgets with Mustache templates. It's sandboxed with DOMPurify, no JS eval. I wanted people to be able to build their own cards without opening security holes.

Retention is configurable per signal. Set 7 days for traces, 30 for metrics, whatever you want. Old data gets cleaned up on its own.

And there's an MCP server at /mcp if you use Claude Code or similar tools. You can query your telemetry from the LLM directly. I didn't expect to use this much but it's actually pretty handy when debugging.

Try it

Quickest way:

docker compose up --build

This starts everything including a sample workload that generates real data, so you're not staring at an empty dashboard.

Or just check the live demo. It's a static build with mock data, login accepts any password: Live demo

The repo is here: GitHub

It's GPLv3. If you try it out let me know what you think, I'm curious what's missing or broken.