Skip to content
Methex
Back to projects

Full-Stack Incident Response Platform

OnCallr

A schedule-aware on-call platform with webhook incidents, live delivery, automatic escalation, timelines, analytics, and AI-assisted postmortems.

WebNext.js 16FastifyPrismaPostgreSQLRedisBullMQSocket.ioOpenAI

Overview

OnCallr is a full-stack incident response and on-call management platform designed for a single engineering team. It combines a Fastify API, Next.js dashboard, PostgreSQL data model, Redis-backed BullMQ jobs, and Socket.io delivery to coordinate incidents from initial webhook trigger through acknowledgement, resolution, postmortem, and analytics. The product supports admins and engineers through protected workflows while using escalation policies and on-call schedules to assign the correct responder automatically.

Challenge

Incident response must remain dependable even when responders do not acknowledge immediately, browser sessions disconnect, or services restart. OnCallr needed durable escalation timers, schedule-aware assignment, secure service-specific webhook ingestion, real-time operator feedback, a complete event history, role-aware actions, and useful post-incident analysis without fragmenting the experience across separate tools.

Impact

The platform centralizes on-call operations into one product, reduces manual responder coordination, preserves a traceable incident history, helps teams understand MTTA and MTTR, and turns resolved incidents into editable AI-assisted learning documents.

Identity

Project profile

Product Scope

Single-team incident response and on-call management

Architecture

Fastify API and Next.js dashboard monorepo

User Roles

Admin and engineer

Delivery Model

Real-time web application with durable background jobs

Project Role

Full-stack product engineering across frontend and backend foundations

Stack

Technology foundation

Frontend

Next.js 16 and React 19

Protected dashboard experiences for incidents, services, schedules, postmortems, and analytics

UI

Tailwind CSS 4 and shadcn/ui

Responsive application shell and reusable operational interfaces

Server State

TanStack Query

API data fetching, caching, invalidation, and dashboard synchronization

Charts

Recharts

MTTA, MTTR, service volume, severity, trend, and on-call load visualization

Backend

Fastify

Typed HTTP APIs, authentication, incident workflows, integrations, and business logic

ORM

Prisma

Relational schema, migrations, queries, and incident data access

Database

PostgreSQL

Persistent services, users, schedules, incidents, events, policies, and postmortems

Queue

BullMQ and Redis

Durable acknowledgement timeouts and automatic escalation processing

Real-Time

Socket.io

Live incident notifications, toasts, and dashboard updates

Authentication

Supabase Auth and Fastify JWT

Magic-link entry and secure in-app cookie sessions

AI

OpenAI Responses API

Generate editable structured postmortem drafts from incident context

Email

Nodemailer

Fallback notification and operational email delivery

Scope

MVP feature set

Incident Intake & Assignment

  • Accept incidents through a unique webhook URL assigned to each managed service.
  • Allow administrators to trigger incidents manually from the service dashboard.
  • Validate service webhook tokens before creating incident and event records.
  • Resolve the active on-call responder from schedule-backed escalation policies.
  • Assign severity and incident context at creation so responders receive actionable information.
  • Deliver immediate live notifications to the selected engineer through Socket.io.

Escalation & Scheduling

  • Create escalation policies with ordered user or schedule-based steps.
  • Build schedules from rotation members and generate future coverage shifts.
  • Support shift overrides and swaps for real operational changes.
  • Enqueue BullMQ escalation jobs when incidents are assigned.
  • Reassign unacknowledged incidents when timeout windows expire.
  • Keep escalation timers durable in Redis so they survive API process restarts.

Incident Operations

  • Track triggered, acknowledged, and resolved incident states.
  • Give engineers a focused My Incidents queue for assigned response work.
  • Maintain a full incident event timeline from trigger through resolution.
  • Support comments, acknowledgement, resolution, and administrator force-escalation actions.
  • Push state changes into active dashboards and toast notifications in real time.
  • Preserve operational context for later postmortem generation and analytics.

Postmortems & Analytics

  • List resolved incidents that are ready for post-incident review.
  • Generate structured postmortem drafts with the OpenAI Responses API.
  • Allow teams to edit AI-generated content before saving the final record.
  • Calculate MTTA, MTTR, incident totals, service volume, severity mix, and time-series trends.
  • Measure busiest on-call coverage to make response load more visible.
  • Filter analytics by date range and service for focused operational review.

Screenshots

OnCallr incident response case study

Incident Operations Dashboard

Screen 01

Incident Operations Dashboard

Live OnCallr dashboard for active incidents, MTTA, MTTR, service health, on-call coverage, and incident timelines.

Architecture

Delivery details

Webhook Incident Pipeline

  • Each service owns a unique webhook token that can be rotated by an administrator.
  • Incoming webhook payloads include incident title, description, and severity.
  • The Fastify route validates the service token before accepting the trigger.
  • The backend creates the incident and its initial timeline event in PostgreSQL.
  • Schedule and escalation policy data determine the first responder assignment.
  • Socket.io notifies the responder while BullMQ schedules the acknowledgement timeout.

Durable Escalation Architecture

  • BullMQ stores delayed escalation work in Redis instead of relying on in-process timers.
  • Queue workers evaluate whether the incident remains unacknowledged when a timeout expires.
  • The escalation service advances through ordered policy steps and records reassignment events.
  • User-based steps assign a specific engineer while schedule-based steps resolve current coverage dynamically.
  • Durable jobs allow escalation behavior to continue correctly after backend restarts.

Schedules & Coverage

  • Administrators create schedules and define ordered rotation membership.
  • Future shifts are generated so responder coverage can be resolved ahead of time.
  • Overrides provide temporary replacement coverage without destroying the base rotation.
  • Shift swaps allow engineers to exchange assigned coverage windows.
  • Coverage data feeds both incident assignment and on-call workload analytics.

Authentication & Permissions

  • Supabase magic links provide the initial frontend authentication experience.
  • The application exchanges authenticated identity for a Fastify cookie-based JWT session.
  • Protected dashboard routes prevent unauthenticated access to operational data.
  • Engineer permissions focus on assigned incidents and response actions.
  • Administrator permissions add service, schedule, policy, analytics, and force-escalation management.

AI-Assisted Postmortems

  • Resolved incidents provide the source timeline and operational context for draft generation.
  • The backend calls the OpenAI Responses API to produce structured postmortem content.
  • Generated drafts remain editable so engineers can correct context and add human judgement.
  • Final postmortem records are saved against the originating incident.
  • The workflow accelerates documentation without treating AI output as an unreviewed final report.

Analytics & Operational Learning

  • MTTA measures the delay between incident trigger and responder acknowledgement.
  • MTTR measures the time required to move an incident from trigger to resolution.
  • Status, service, severity, and time-based summaries expose incident patterns.
  • On-call load analysis shows which responders or coverage windows carry the most activity.
  • Date-range and service filters let administrators isolate meaningful operational slices.

Monorepo & Local Development

  • api contains the Fastify server, Prisma schema, BullMQ jobs, and Socket.io delivery layer.
  • web contains the Next.js dashboard and frontend integrations.
  • docs contains deployment and demo guidance while features.md records product behavior.
  • PostgreSQL and Redis provide the required local persistence and queue infrastructure.
  • Prisma migrations and seed scripts create demo services, schedules, admins, and engineers.
  • Separate frontend and backend development servers run on ports 3000 and 5000.

Quality & Deployment

  • Frontend and backend packages each provide lint and production build checks.
  • The Next.js dashboard is suited for deployment on Vercel.
  • The Fastify API can run on Railway, Render, or Fly.io.
  • PostgreSQL can use Supabase or Railway while Redis can use Upstash or Railway Redis.
  • WEB_ORIGIN and public API or Socket URLs connect deployed frontend and backend services safely.
  • SMTP and OpenAI credentials enable email fallback and AI postmortem generation outside local development.