// Self-hosted observability

Know before your users do

A monitoring stack on your own infrastructure that tells you what broke, on which host, before a customer opens a ticket. Grafana, Prometheus, Loki and Alertmanager, deployed and documented, with the admin credentials handed to you.

You own it. Open-source editions throughout — no per-host fees, no ingest metering, no seat licences, and no vendor who can reprice you next year.

Read a sample handover doc ↗

// The problem

Self-hosted, and that is the point

Hosted monitoring is priced per host, per seat or per gigabyte. It is fine at three servers. At thirty it is a line item somebody starts asking questions about, and the usual answer is to monitor less, which is exactly backwards.

What this avoids

Per-host billing. Adding a server should cost you a server, not a server plus a subscription tier.
Ingest metering. Logs are most useful in exactly the week you produce the most of them, which is when metered billing punishes you hardest.
Data leaving your perimeter. For some businesses this is a preference. For others it is the reason hosted was never an option.
Lock-in. Dashboards, alert rules and config are plain files. Move the whole thing to another server on a Sunday if you want to.

// What you get

Six things, delivered and tested

The handover

The stack — Grafana, Prometheus, Loki, Promtail and Alertmanager, deployed with Docker Compose so it is reproducible rather than hand-assembled.
Dashboards for CPU, memory, disk, network, uptime and service health, built around your hosts rather than a stock import.
Alert rules that have each been fired deliberately before you get them.
Centralised log search across every host through Loki and Promtail, so an incident is one query rather than an SSH tour.
Administrator credentials. Yours, not shared, not retained.
A handover document written so somebody who was not in the conversation can still run it.

What it can watch

Linux servers, through Node Exporter
Docker containers, through cAdvisor
Nginx and Apache
MySQL, MariaDB and PostgreSQL
AWS CloudWatch metrics
REST APIs and endpoint uptime
TLS certificate expiry

Where alerts land

Slack
Email
Microsoft Teams
Telegram
Discord
PagerDuty
Any generic webhook

// How it works

From scoping to credentials

Scoping

How many hosts, what runs on them, what you need alerting on, and how long you want to keep data. Retention is the setting that decides your disk, so it gets decided rather than defaulted.
Deployment

The stack goes up on the host you nominate, through Docker Compose. Exporters go onto the machines being monitored.
Dashboards and rules

Built against your real data, not a demo dataset. Then every alert rule is triggered on purpose so you watch it arrive in your own channel.
Handover

Admin credentials, the configuration, and the document. On the full package the config is in Git, so future changes have a history.

// Packages

Three sizes

Scope is fixed per package. Current pricing and delivery times live on Upwork, where they are kept up to date.

Starter

One Linux server. The first step out of not knowing.

Single server
Core dashboards
Core alert rules
One notification channel
Handover document

Recommended

Standard

Several servers, containers, and the log search that makes an incident solvable.

Multiple servers
Centralised log search
Docker container metrics
One additional data source
Two notification channels
Handover document

Advanced

Larger infrastructure, cloud accounts, databases and the business numbers on the same screen.

Multiple sources including AWS CloudWatch
Databases and REST APIs
KPI dashboards
Git-managed configuration
Post-delivery email support
Handover document

Not ready to run a stack yourself? The Hosted Monitoring project is the same dashboards on my platform, with nothing for you to maintain — and there is a live demo you can open right now.

Tell me what your estate looks like.

How many servers, what runs on them, and what you would want to be woken up for. You get a scope, a timeline and an honest read on whether you need the full stack or something much smaller.

Send me a message ↓

Prefer to talk? Book a free call ↗ · Or hire me on Upwork ↗ · Typical reply within one business day.

// FAQ

Questions

What does self-hosted actually cost to run?

The software costs nothing. This is the open-source edition of Grafana, Prometheus and Loki, so there is no per-host billing, no ingest metering and no seat licence. What you pay for is the server it runs on, which for most small estates is one modest VM, and the one-off work of setting it up properly. That is the entire argument for doing it this way: the cost stops growing when your infrastructure does.

What happens if you disappear?

Nothing breaks. You hold the admin credentials, the stack runs on your server, and the configuration is plain files you own. That is deliberate, and it is the reason the handover document exists — it is written so somebody who was never in our conversation can pick it up. On the larger package the configuration is kept in Git, so the history is yours too.

How much of my server does it use?

Less than people expect for a small estate. The exporters that sit on each monitored host are tiny. The collector itself is the part that grows, and it grows with retention rather than with hosts, so the lever you control is how far back you keep data. That gets sized during scoping rather than guessed at, because a monitoring stack that fills the disk is worse than none.

Why do I need log search if I already have dashboards?

Because a dashboard tells you something broke and a log tells you why. The usual sequence is a graph spiking, then twenty minutes of SSH-ing between hosts running grep. Loki collapses that into one search across every machine, filtered to the minute the graph moved. It is the difference between knowing you had an incident and knowing what caused it.

Do the alerts actually work, or do they just exist?

Every rule is triggered deliberately before handover. An alert that has never fired is an assumption, and the ones people rely on most are frequently the ones that were never tested — a disk rule with the threshold in the wrong unit sits silent for a year and then does not fire on the night it matters. You will see each one arrive in your channel before I hand it over.

Can you monitor things that are not Linux servers?

Yes. Docker containers, Nginx and Apache, MySQL, MariaDB and PostgreSQL, AWS CloudWatch, REST APIs and certificate expiry are all standard. Business metrics work too, provided the number can be reached from the monitoring host — orders per hour and failed payments belong on the same screen as CPU, and almost nobody puts them there.

Should I start here or with hosted monitoring?

Start here if you have somewhere to run it, want the data inside your own perimeter, and expect to add hosts. Start with the hosted project if you want to see something this week and do not want a stack to look after. Moving from hosted to self-hosted later is a normal path — Grafana dashboards are portable, so nothing is thrown away.