r/DatabaseAdministators

Disclosure: I’m part of the team building a database governance platform called DataGuard.

Across engineering teams, we kept seeing the same operational problems repeat:

• permanent production database access
• schema changes happening through Slack + terminal sessions
• audit visibility scattered across multiple systems
• support teams having broader customer-data access than necessary
• production credentials living in .env files

One thing we’ve learned while working on this space:

Most database security problems are actually workflow and operational-governance problems.

Curious how teams here currently handle:

• production DB access
• schema approvals
• audit readiness
• secrets rotation
• PII masking

Especially interested in how larger teams handle temporary production access and auditability without slowing engineering down.

Recently there was yet another real-world case of an AI assistant generating a destructive command during a workflow.

The mistake itself wasn’t the scary part.

The problem isn’t that AI might break something. It’s that your backups weren’t usable when you needed them.

https://sqlbak.com/blog/the-problem-isnt-that-ai-might-break-something-its-that-you-didnt-have-backups/

I’ve been working in observability for ~7 years now across logs, metrics, traces, database performance, the whole stack.

And honestly... something has always felt off.

Tools like Datadog, New Relic, Grafana they’re powerful, no doubt. But after using them in real production environments, I kept running into the same gaps:

Too much fragmentation (metrics here, traces there, DB somewhere else)

Expensive at scale (especially when data explodes)

Hard to get actual root cause, not just dashboards

Database monitoring still feels like a “bolt-on,” not first-class

Alert fatigue is real — lots of noise, not enough clarity

Most of the time, we’re not lacking data — we’re lacking context and correlation.

That’s what got me thinking...

Why isn’t there a tool that treats databases as the core of observability, not just another integration?

Why do we still jump between 4–5 tools to debug one issue?

Why is “full-stack observability” still so disconnected in practice?

So I’ve decided to build something.

I’m working on a new product called Obsfly — an advanced database-centric observability platform designed for both on-prem and cloud environments.

The idea is simple (but ambitious):

Deep, real-time database visibility (queries, locks, performance)

Native correlation between DB ↔ application ↔ infrastructure

Smarter anomaly detection (less noise, more signal)

Built for scale without punishing costs

Actually helps you find root cause — not just visualize problems

I’m not claiming I’ll beat the big players overnight. But I’ve seen enough pain in real systems to believe there’s space for something better.

Right now, I’m validating ideas and talking to engineers/DBAs.

If you’ve worked with observability tools:

What frustrates you the most?

What’s still missing today?

What would make you switch tools instantly?

Would love brutally honest feedback 🙏

https://www.obsfly.live/