All articles
Product/June 21, 2026/3 min read

Introducing OpenPulse: Self-Hosted Observability with AI Root-Cause Analysis

Observability forces a bad trade off: an expensive SaaS bill with your data offsite, or a stack you babysit yourself with no AI insight. OpenPulse is the third option, self hosted logs, traces and metrics with AI root cause analysis and auto remediation built in.

Observability Should Not Cost You Your Data or Your Weekend

Every team running production software reaches the same fork.

One path: send all your logs, traces and metrics to a SaaS observability vendor. It works on day one, and then the bill arrives. Per gigabyte ingestion pricing turns a noisy deploy into a budget problem, and every byte of your telemetry now sits on someone else's infrastructure, outside your perimeter.

The other path: build it yourself from open source parts. You get data ownership and no ingestion bill, plus a second full time job. Now you are on call for your own monitoring stack, stitching together collectors, storage and dashboards, and you still have nothing that tells you why the system broke at 3am.

We did not like either option, so we built a third one.

Introducing OpenPulse

OpenPulse is a self hosted observability platform for logs, traces and metrics, with AI root cause analysis and auto remediation built in. It runs on your own infrastructure, so your telemetry never leaves your control.

It is the platform we wanted: the data ownership and predictable cost of running your own stack, without the operational burden, and with the analysis layer the do it yourself stacks have never had.

When Something Breaks, It Tells You Why

This is the part that makes OpenPulse different from a wall of dashboards.

When an incident starts, OpenPulse correlates the relevant logs, traces and metrics and gives you the likely root cause in plain language, not a red graph and a link to 40,000 log lines. Instead of starting the investigation, you start with a hypothesis.

It does not stop at diagnosis. OpenPulse can propose a fix and, with your approval, apply it. Auto remediation sits behind an explicit approval gate. Passive tools tell you the disk is filling up. OpenPulse tells you why, proposes the remediation, and waits for you to say go. That approval step is deliberate. Nothing changes in your environment without a human signing off.

One Platform Instead of a Pile of Tools

OpenPulse puts logs, traces and metrics in one place, so following a single request through your system does not mean three tools and four tabs.

Ingestion is standards based: native OpenTelemetry over gRPC and HTTP. Point your existing instrumentation at OpenPulse and your services are discovered from the telemetry itself. No proprietary agents to roll out, nothing to rip out and replace. If you emit OTLP today, you are most of the way there.

On top of that you get the operational basics done properly: alerting with evaluation and notifications, uptime and TLS certificate monitoring, saved queries, and live dashboards that stream telemetry as it arrives.

Self Hosted by Design

OpenPulse runs on your infrastructure with Docker Compose and stores data in PostgreSQL with TimescaleDB. Your telemetry stays inside your network. There is no per gigabyte meter running, and there is no copy of your production data in a vendor's cloud.

Staying current is one click. The licensed registry based updater fetches the new version, runs migrations, recreates services, health checks the result, and rolls back automatically if anything fails. Self hosted, but not on your own.

Who It Is For

OpenPulse is built for .NET engineering teams, platform, SRE and DevOps engineers, and engineering leaders at small and mid size companies who run their own infrastructure and care about three things: keeping their data inside their walls, keeping the observability bill predictable, and giving engineers answers instead of more graphs.

The backend is .NET 10, written by people who work in the .NET ecosystem every day. Because ingestion is plain OTLP, it takes telemetry from any language or runtime you have instrumented.

How It Works

The shape is simple. Your services emit OpenTelemetry over OTLP to OpenPulse running in your environment. It stores everything in Postgres and TimescaleDB on your hardware and shows it as live, correlated logs, traces and metrics. When something goes wrong, the AI layer looks at the correlated signals, names the likely cause, and if you allow it, proposes and applies the fix. You own all of it.

Try It in Your Own Environment

OpenPulse is commercial and self hosted, with three tiers. Standard for core observability, Pro for AI root cause analysis and auto remediation, and Enterprise for SSO and RBAC, multiple instances, white labelling and support.

There is no free tier, because a free tier would only give you a toy. Instead you get a time limited evaluation licence, so you can run the real thing on your real infrastructure and judge it on your own telemetry.

Share

Keep reading

October 20, 2026 · 14 min

Are Coding Agents Getting Worse, or Have They Lost Their Teachers?

Many developers say agent-written code keeps getting worse and blame the models. The evidence points closer to home: agents copy the codebase they work in, and more and more of that codebase is their own unreviewed output.

Read

October 18, 2026 · 8 min

The Narrow Sidewalk: Where Developers Stand When Agents Write the Code

Agents write much of the code now, and that is not going back. But green checks can still hide wrong meaning, and someone has to know what correct code looks like. Here is the narrow path between writing every line and writing none, with tested C#.

Read

October 16, 2026 · 16 min

Why Agents Need a Knowledge Base: The Gaps an LLM Can't Fill by Itself

A model knows only what was in its training data, up to its cutoff, and very little about specialised fields or your own systems. Here are the four gaps a knowledge base fills in an agentic system, why a 1M token context window doesn't close them, and how to expose one to an agent in C#.

Read