Stack Déploiement + Monitoring + Observabilité

What's in this pack

This is the stack a working backend engineer would assemble the week before their app gets real users — not the heroic post-outage scramble. Every pick here is open-source-first, runs on a $20 VPS or smaller, and plugs into the next tool in the chain. The order matters: each layer feeds the next.

Install in this order (deploy → traces → logs → metrics → uptime → alerts → dashboards)

The order is deliberate. Don't install dashboards first. Empty dashboards teach you nothing. Wire the data sources first; the dashboard is the last 10% of the work.

1. Pick one deploy target. Vercel CLI if you're shipping a JS framework and want preview URLs on every PR. Kamal if you've outgrown Heroku-style pricing and want to own the box. Coolify if you want the Vercel UX on your own hardware. Pick one. Skip the other two.
2. Sentry next. Errors are the single highest-signal telemetry you'll add. Five lines of SDK init and you start catching exceptions you didn't know existed. Set up release tracking from day one so you can answer "did this start with the last deploy?"
3. OpenTelemetry Collector. Don't lock yourself to one vendor's SDK. The Collector is a single Go binary that receives OTLP from your app and fans out to Sentry, Prometheus, Loki, or anything else. Configure it once, swap backends without touching app code.
4. Prometheus for metrics. Scrape /metrics from your app, your Node Exporter, your database exporters. The four golden signals — latency, traffic, errors, saturation — go here.
5. Loki for logs. If you already use Prometheus, Loki is the obvious log store: same label model, same query language flavor, runs on the same VM. Don't index every JSON field; index by service, env, level — let LogQL filter the rest.
6. Uptime Kuma for the heartbeat. External-perspective ping. Catches the outages your internal stack can't see (DNS, TLS cert, CDN). Public status page included.
7. Alertmanager wired to Prometheus. Alerts should fire on symptoms (p95 latency > 2s, error rate > 1%), not causes (CPU > 80%). Route P1 to pager, P2 to Slack, P3 to a daily digest.
8. Grafana last. Now that data is flowing, build three dashboards: one for the on-call engineer (latency, error rate, recent deploys), one for the product owner (signups, conversions, cost per user), one for the exec (uptime %, MAU, week-over-week). Generic dashboards get ignored.

Tradeoffs you'll hit

• Vercel vs Kamal vs Coolify — Vercel = zero-ops, scales to zero, gets expensive at scale and you don't own the stack. Kamal = own the box, Docker is the only abstraction, cheap and predictable. Coolify = the middle ground; self-hosted UI on top of Docker. Most teams ship the MVP on Vercel, migrate to Kamal/Coolify when the bill hits $500/mo.
• Sentry SaaS vs self-hosted — Self-hosted Sentry needs ~6 services (Kafka, Postgres, Redis, ClickHouse). For under 100k events/month, the SaaS free tier is genuinely cheaper than your time. Self-host only when you're past the free tier and have ops bandwidth.
• Prometheus + Loki + Grafana vs Datadog — Datadog is the polished hosted incumbent. The open stack costs ~$20/mo in VPS instead of $300+/mo per host. Tradeoff: you babysit the stack. Below ~10 services, open-source wins on cost and lock-in; above ~50, Datadog's ergonomics start to matter.
• Push vs pull metrics — Prometheus is pull (it scrapes you). If you run serverless or short-lived jobs, pull doesn't work — use a Pushgateway, or switch to OpenTelemetry push to a Collector. Don't fight the model.

Common pitfalls

• Alerting on causes, not symptoms. "CPU > 80%" pages you at 3am for a workload that's fine. "User-facing p95 > 2s" pages you only when it matters. Tune for symptoms; investigate causes after waking up.
• No release annotation in Grafana. Half of all incidents start "right after the deploy." Wire your deploy script to POST a Grafana annotation on every release. The flame on the timeline saves 20 minutes per incident.
• Indexing every log field. Loki's whole point is that it doesn't. If you add 50 labels per log line, cardinality explodes and the cheap log store becomes expensive. Index by service, env, level — grep the rest.
• One alert channel for everything. P1 (site down) → phone. P2 (degraded) → Slack with @channel. P3 (anomaly) → daily digest. Mix them and either you ignore the pager or you ignore the digest. Both fail.
• No external uptime check. Your internal Prometheus thinks the service is up. Cloudflare or your CDN is dropping 30% of requests in eu-west. Uptime Kuma from a different network catches this. Five minutes to set up.