For a long time, my monitoring setup was a database table. Logs written to SQL Server, a query I had saved somewhere, and a lot of SELECT * FROM Logs WHERE Level = 'Error' ORDER BY Timestamp DESC whenever something went wrong.
I am not proud of it. But it worked well enough that I kept doing it for longer than I should have.
The problems were obvious in hindsight. You only looked at logs when something broke. There was no sense of trend, no way to see that error rates had been slowly climbing for three hours before the support ticket arrived. You were always reacting, never watching. And querying a database table to understand a live system is just wrong in a way that is hard to articulate until you try something better.
The First Time I Opened Grafana
I set up Grafana properly for the first time on a project that was having performance issues nobody could pin down. Response times were slow, but not catastrophically so. Users were complaining, but the logs showed nothing obviously broken.
Within an hour of having Prometheus scraping our .NET API and Grafana showing the latency histogram, the problem was visible. One specific endpoint was hitting P95 around 4 seconds. Everything else was fine. The database table would never have shown me that, because nobody would have thought to look for it specifically.
That was the moment I stopped treating observability as something you bolt on when things go wrong.
Why Not Just Use What Azure Gives You?
Application Insights is the obvious choice if you are on Azure. It is already there, it integrates with .NET in about five minutes, and Microsoft keeps improving it. I have used it on multiple projects and it is genuinely good.
But it ties you to Azure. Every metric, every trace, every dashboard lives inside the Azure portal. If the project moves clouds, you rebuild everything. If you want to combine data from services running elsewhere, you can't. Your dashboards, your alert rules, your institutional knowledge about what normal looks like — all of it is locked inside one vendor's ecosystem.
Grafana does not care where your data comes from. It talks to Prometheus, Loki, Azure Monitor, CloudWatch, Elasticsearch, PostgreSQL, and a dozen other sources at the same time. You can run it anywhere. Your dashboard JSON is just a file you can version control and take with you. That portability matters more than most people realise until they actually need it.
What Good Observability Actually Feels Like
The difference between querying logs in a database and watching a live Grafana dashboard is roughly the difference between reading yesterday's newspaper and looking out the window.
When something goes wrong now, I open the dashboard first. Error rate panel tells me if it is widespread or isolated. Latency panel tells me if it started suddenly or has been degrading. The deployment marker (Grafana lets you annotate time series with events) tells me if a release is correlated. Most of the time I know what is happening before I have opened a single log file.
The logs still exist. They are still useful for drilling into individual requests. But they are the last step, not the first.
It Also Changes How You Write Code
Once you have dashboards you actually look at, you start thinking about metrics while you are writing code. Not in a heavy, over-engineered way. More like: "I am going to want to know how often this background job fails, so I will add a counter." It takes thirty seconds and it pays off the first time something goes wrong at 2am and you do not have to deploy a hotfix just to add visibility.
That feedback loop — code, observe, understand, improve — is what good tooling is supposed to enable. A database log table breaks the loop because checking it is friction. Grafana removes that friction.
The Switch Was Worth It
I do not think the database-as-log-store approach is embarrassing exactly. It is a reasonable thing to reach for early in a project when there are a hundred other things to figure out. But staying there too long is a mistake I made and would not make again.
Grafana with Prometheus is not complicated to set up. It runs fine in Docker locally. It runs fine in Kubernetes in production. It costs nothing to self-host, or very little on a managed offering. And it gives you a level of understanding of your running systems that you simply cannot get any other way.
If you are still using a log table, set aside an afternoon. You will not go back.
