Meridian

API reliability made actionable

Comment

Inspiration

APIs now carry the most important parts of a product: payments, authentication, data, and integrations. Yet teams often discover an API problem only after a user reports it. I wanted to make API reliability visible, continuous, and understandable—not just to experienced backend engineers, but to everyone on a team.

What it does

Meridian is a self-hosted API reliability command center. It continuously tests REST and GraphQL APIs, explains failures in plain language, and turns them into actionable operations.

It provides:

  • Four-layer validation: connectivity, authentication, contract, and data assertions.
  • Recurring probes, private-network agents, and multi-step transaction workflows.
  • Incident creation, acknowledgement, resolution, deployment correlation, and alert delivery history.
  • Slack, Microsoft Teams, and SMTP alerts.
  • Trend analytics, target-level insights, L1–L4 failure breakdowns, SLOs, error budgets, and release gates.
  • Enterprise controls including roles, scoped CI tokens, MFA, OIDC, SSRF protection, audit history, session management, and retention controls.

How we built it

Meridian uses Go and Gin for the API, React, TypeScript, Vite, and Recharts for the dashboard, PostgreSQL and MongoDB for persistence, and Docker Compose for one-command local deployment.

We built it iteratively with Codex in ChatGPT using GPT-5.6 as a collaborative engineering partner. Codex helped us develop the backend and dashboard, troubleshoot Docker and TypeScript build issues, improve the product flow, add security controls, and validate the application through tests and repeated end-to-end checks.

Challenges we ran into

The hardest part was making a technically deep product feel simple. A failed API call can mean many things: unreachable host, missing authentication, changed response contract, incorrect data, or a recent deployment.

We also had to balance a growing feature set with a clean dashboard, secure the platform against SSRF and credential exposure, and make private-network monitoring possible without opening inbound access to internal services.

Accomplishments that we're proud of

  • Turning raw probe failures into a clear L1–L4 explanation that tells users what failed and where.
  • Building a complete reliability workflow: probe, detect, alert, investigate, resolve, and learn.
  • Adding private agents so teams can monitor internal APIs safely.
  • Making reliability features such as SLOs, error budgets, and release gates approachable for teams with limited API experience.
  • Delivering a self-hosted system that can be started locally with Docker Compose.

What we learned

Reliability tooling should not merely report that something failed—it should reduce the time needed to understand what happened and decide what to do next.

We also learned that thoughtful product structure matters as much as implementation. Clear language, focused pages, and visible next actions turn complex operational data into something people can confidently use.

What's next for Meridian

Next, we plan to add richer workflow templates, anomaly detection, deeper trace and log integrations, expanded SSO provider support, team collaboration features, and more advanced reporting for reliability trends across services and environments.

Built With

Share this project:

Updates

Submission history