# Relia: the agent that watches your product (full context) > Relia watches your product end to end, learns what's normal for it, and tells you only what needs you, with the cause and the next step. For founders and small teams without an SRE. Free for one product. ## Overview Relia is an observability agent for solo founders and small teams with no one whose job is to watch production. It watches the whole product, learns what is normal for that app from its own traffic, and tells the founder in plain words only what needs them, with the cause and the next step. Everything it says is grounded in the project's own evidence. ### What it watches - Users' sessions: clicks, navigation and errors (what people type is never sent; screen replay is off unless switched on) - API requests: errors, latency and volume per route - Database calls: failures and slow queries (statement values are masked in the SDK) - Servers: CPU, memory and disk - Uptime from outside, synthetic checks (Growth and Pro), and a public status page (Atom feed, webhook; your logo and your own domain on Growth and Pro) - App logs: warnings and errors your server writes, grouped by message pattern - Web vitals: page load, responsiveness and layout shift - Browser errors mapped to your source files through uploaded source maps - Identified users (optional): who hit a problem and on which plan - AI-agent runs inside your requests ### What it hands you - Incident write-ups in plain words: what happened, why Relia thinks so, and one thing to do next, with every number cited from the evidence. - Fix plans written from that evidence, with a "Copy for your AI assistant" brief. - Fix checks: after you deploy, Relia watches live traffic and tells you whether the fix worked. - Ask Relia: questions about your product, answered from its own incidents and facts. - Visitors: who comes, from where, on what device and browser, and which pages, browsers or countries run into errors far more than the rest (bots left out). - Funnels: Relia finds your main journeys itself (sign-up, checkout…); each step says where people went instead and why they left (failed requests, errors, slow pages, who is affected), and a sudden conversion drop becomes an incident. Your own funnels and the "why" on Growth and Pro. - Dashboards: pick charts without writing queries, start from templates, or ask Relia ("checkout errors by country this week") and keep what it proposes; TV mode and PNG / CSV export on Growth and Pro. - An MCP server: AI coding assistants (Claude Code, Cursor, VS Code, Windsurf, Codex, Gemini CLI, Claude Desktop, any MCP client over HTTP) connect once per person, by signing in from the tool or with one account token, and reach every project the person can see (or the ones they choose). They read what needs you, incidents, fix plans, evidence and Ask Relia answers, and can set Relia up in a repository. The only changes they can make (mark a fix, give a verdict, acknowledge, report a deploy, create a project) need the founder's explicit yes and are in the audit log. - Postmortems in one click once an incident is fixed: timeline, impact, cause and lessons, editable, publishable as a masked public link. - A daily or weekly summary, and one message per incident on Slack (with buttons: I'm on it, show the fix, this is expected), email, ClickUp, Jira or PagerDuty. On Free, Relia finds problems and e-mails a one-line alert; the write-ups, fix plans, postmortems, summary and Slack, ClickUp, Jira and PagerDuty alerts come with Growth and Pro. ### What it does not do Relia does not change your code and never opens pull requests. It never acts on your servers on its own: it can propose a rollback or a restart through a connected Render, Vercel, GitHub Actions or webhook integration, and that runs only after an owner or admin approves it (two approvals if you require them). ## Plans and units (https://tryrelia.com/pricing) | | Free | Growth | Pro | | --- | --- | --- | --- | | Price | $0 | $19 a month ($15 a month billed yearly ($180)) | $49 a month ($39 a month billed yearly ($468)) | | Relia finds problems and e-mails you | Yes | Yes | Yes | | Why it happened, who it hit, what to do | No | Yes | Yes | | Fix plans a month | No | 30 | 50 | | Ask Relia questions a month | 30 | 100 | 300 | | Postmortems a month | No | 10 | 30 | | Dashboards made in Ask Relia | 2 | 10 | 30 | | Funnels Relia finds and watches | 3 | 10 | 30 | | Your own funnels, and why people leave | No | Yes | Yes | | Daily summary, checks, promises (SLOs) | No | Yes | Yes | | Alerts in Slack, ClickUp and Jira | No | Yes | Yes | | On-call and PagerDuty | No | Yes | Yes, with escalation | | Team members | 1 | 5 | Unlimited | | Units a month | 250,000 | 5 million | 20 million | | History | 7 days | 30 days | 90 days | | Visitor trends | 30 days | 6 months | 1 year | | Services | 3 | 10 | Unlimited | | Uptime monitors | 5 | 20 | 50 | | Relia's synthetic check runs a month | No | 20,000 | 60,000 | | Status page | Relia-branded | Your domain and logo | Your domain and logo | | MCP in your editor | Status and headlines | Full | Full | | Over the limit | Sampled, never cut off | Sampled, or paid extra use | Sampled, or paid extra use | | Extra use | Not available | $2 per million units, with a limit you set | $2 per million units, with a limit you set | A request or a log line is 1 unit, a session minute 35, an agent run 5, a page view in analytics-only mode 1, a mobile app 300 per device per month (each phone that opens your app counts once a month, however much it is used; crashes free). One project per plan; your first project is free. Prices exclude tax. Every plan includes a public status page and People (which customers each problem hit). Over the limit nothing is cut off: normal traffic is sampled 1 in 10 and errors are always kept. Cancel anytime: you are not charged again and the project moves to Free at the end of the paid period. ## Setup `npx relia-sdk@latest init` in the app's folder or a repo's root (Node.js, Next.js, browser apps and AI agents; it installs the SDK in each app it finds), or `pip install relia-sdk` then `python -m relia` (FastAPI, Django, Flask), or `composer require tryrelia/relia` then `php artisan relia:install` (Laravel; plain PHP: `\Relia\Relia::start([...])`; pure PHP 8.1+, no extension). Supabase and Firebase apps: the web app as above (Supabase table calls become value-free database statements, RLS refusals and Firebase errors are named), Edge Functions / Deno / Cloudflare Workers wrapped with `withRelia` from `relia-sdk/edge`, Firebase Cloud Functions with `relia-sdk/node` (sent before the function ends), and optionally the Supabase database's own statistics (slow queries, failed or stopped pg_cron jobs, connections) through a read-only login. Mobile apps: Flutter (`flutter pub add relia_flutter`, then `Relia.init(...)` before `runApp` and `Relia.navigatorObserver` for screens; Android Java / Kotlin crashes, freezes and memory kills too) and React Native / Expo (`relia-react-native`: `Relia.init(...)` and `export default Relia.wrap(App)`; release builds upload their source map and R8 mapping, so crashes are readable); `npx relia-sdk@latest init` sets up either. They record screens, taps, API calls (joined to the backend with traceparent), crashes and freezes, app version and phone model; pricing: 300 units per device per month (each phone that opens the app counts once in the calendar month, however much it is used), crashes free. Go, Rust, Java / Kotlin, .NET, Ruby and any OpenTelemetry app: the official OpenTelemetry SDK (or the Java agent, no code change) with OTEL_EXPORTER_OTLP_ENDPOINT=https://devotel.tryrelia.com, OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf, OTEL_EXPORTER_OTLP_HEADERS=x-relia-key=, OTEL_RESOURCE_ATTRIBUTES=relia.project_id=; an app already on OpenTelemetry changes only these settings. The setup signs you in, finds what the folder contains (an API, a web app, a Next.js app, AI SDK calls), asks two questions (record screen replays, off by default; identify users, opt-in), writes the files and sets up source maps. Or connect your AI assistant over MCP and say "Set up Relia". The project's Setup tab then shows what has arrived. About five minutes. Details: https://tryrelia.com/setup Packages: npm https://www.npmjs.com/package/relia-sdk and PyPI https://pypi.org/project/relia-sdk/ (both named relia-sdk), Packagist https://packagist.org/packages/tryrelia/relia (tryrelia/relia, PHP), pub.dev https://pub.dev/packages/relia_flutter (relia_flutter, Flutter) and npm https://www.npmjs.com/package/relia-react-native (relia-react-native, React Native / Expo). Tell Relia who your users are with `Relia.identify(id, { email, name, plan })` in the browser, `relia.setUser(req, { id, plan })` in Node `relia.set_user(id, plan=...)` in Python, or `\Relia\Relia::setUser($id, $plan)` in PHP (Laravel sends the signed-in user's id by itself). ## MCP server (https://tryrelia.com/mcp) Relia has a remote MCP server at https://devreliaapi.tryrelia.com/mcp (Streamable HTTP, OAuth sign-in). Set it up once per person: `npx -y relia-sdk@latest mcp install` adds Relia to every AI tool it finds (Claude Code, Cursor, VS Code, Windsurf, Codex, Antigravity, Gemini CLI), and each tool signs in through the browser the first time; Claude Desktop and claude.ai add it as a custom connector. For CI or tools that can't sign in, create an account token on the Profile page and send it as "Authorization: Bearer ". One sign-in or token covers every project the person can see (or the ones they choose); tools take a `project` argument. Read tools: relia_projects, relia_status, relia_list_incidents, relia_get_incident, relia_get_fix_plan, relia_ask, relia_funnels, relia_dashboards, relia_dashboard, relia_trace, relia_logs, relia_session, relia_database, relia_vitals, relia_uptime, relia_changes, relia_setup (this project's exact setup steps; the assistant asks the founder two questions and shows every change before writing) and relia_check_setup. Actions that need the founder's explicit yes (`confirm: true`) and are audited: relia_mark_fixed, relia_set_verdict, relia_ack, relia_report_change, relia_create_project. Say "Set up Relia in this repository" to install Relia from the editor. Full guide: https://tryrelia.com/docs/connect-ai-assistant. ### What is the Relia MCP server? A remote MCP (Model Context Protocol) server built into Relia. AI coding assistants such as Claude Code, Cursor and VS Code connect to it and can read your project's status, incidents, evidence and fix plans, and ask Relia questions about your product's live data. ### Which AI tools work with it? Claude Code, Cursor and VS Code, with the exact setup shown in Relia, and any other MCP client that supports a remote server over HTTP with an Authorization header. ### Can my assistant change anything through it? Not in Relia or on your servers: every tool only reads. Your assistant edits code in your own editor, as it always does, and shows you the change first. When it sets Relia up for you, that is also an edit in your editor that you approve. ### Does it cost extra? No. It is included in every plan. On Free it reads your status and incident headlines; Growth and Pro add the full incidents, evidence, fix plans and Ask Relia. Fix plans and Ask Relia answers fetched through it count against your plan's monthly allowance, exactly as in the app. ### Do I need to install anything? No package. It is a remote server: create a token in Relia and add one line or one small config file to your tool. ### Where does the data go? Relia answers your assistant over HTTPS. What your assistant reads is then sent to the model your tool uses (for example Anthropic for Claude Code), like any other context you give it. Relia never includes the identities of your users in these answers. ## Data, privacy and security Data is stored on AWS in Mumbai, India (ap-south-1): telemetry in ClickHouse, accounts and settings in MongoDB Atlas. Telemetry is kept for the plan's history (7, 30 or 90 days) and deleted automatically every day. AI provider: Anthropic. Relia is operated by Alaknanda Infoplus, a sole proprietorship registered in Gujarat, India. Privacy contact: relia@alaknandainfoplus.com. Security: https://tryrelia.com/security ## Questions ### Will Relia change my code or my servers? No. Relia reads telemetry your SDK sends and tells you what it found. It never opens pull requests, and it never acts on your servers on its own: when an incident follows a deploy or a memory leak, it can propose a rollback or a restart through Render, Vercel, GitHub Actions or a webhook you connected, and that runs only after an owner or admin approves it. The only things it changes on its own are inside Relia: its own checks, promises and learned patterns, each logged with Undo. ### What does it watch? Users' sessions (clicks, inputs, navigation, errors; no screen recording by default), mobile apps (Flutter, React Native and Expo: screens, taps, API calls, crashes and freezes), API requests, database calls, servers (CPU, memory, disk), uptime from outside, your status page, web vitals and AI-agent runs. One project per app. ### Does it work with Cursor, Claude Code or VS Code? Yes, through MCP. Create a token in your project settings and paste the one line Relia shows into your tool. Your AI assistant can then read what needs you, incidents, fix plans and Ask Relia answers, and fix the code in your editor. A token is read-only, for one project, and every read is in your audit log. Details: tryrelia.com/mcp. ### Can Relia tell me exactly which customers hit a problem? Yes, once you tell it who is signed in: one `Relia.identify()` call in your web app (and `setUser` on your server). Incidents then say “38 customers, 9 on Pro” instead of “38 visitors”, the People page shows each person's sessions and errors, and you can reach out before they write to you. Only the id, e-mail, name and plan you pass are kept; names and e-mails never go to the AI or into alerts, and you can export or erase anyone. ### How long does setup take? About five minutes. `npx relia-sdk@latest init` finds your API and web app, asks two questions and writes the config; or ask your AI assistant to “Set up Relia”. Node (Express, Fastify, Next.js, NestJS, Koa…), Python (FastAPI, Django, Flask…) PHP (Laravel, plain PHP, shared hosting) and mobile apps (Flutter, React Native, Expo) have a one-command setup; Go, Rust, Java, .NET and Ruby connect through OpenTelemetry, the open standard, with a few lines of setup (or none, if they already use it). ### How is “normal” decided? From your own traffic: four weeks of per-route behaviour (error rate, speed, volume by hour of the week) and what your users usually do. Relia raises latency or error alarms only when they are also above your app's learned normal, so a busy Monday morning is not an incident. ### Will it flood me with alerts? No. Only incidents that need a fix are sent, at most five an hour (the rest bundled), one “came back”, one “resolved” per incident per day. Everything else waits for Home (and the daily summary on Growth and Pro). ### What happens when I go over my units? Nothing is cut off and nothing already stored is deleted. New normal requests and sessions are kept 1 in 10 until the month resets; errors, slow requests and anything an incident points at are always kept in full. Growth and Pro can switch on paid extra use instead, with a monthly limit. ### Where is my data and how long is it kept? In Relia's databases (MongoDB Atlas and ClickHouse), scoped to your project. Request and session data is kept for your plan's history (7, 30 or 90 days); older data is deleted. Statement values in database queries are masked in the SDK before they leave your server. ### Can my team use it? Yes. Invite members as owner, admin, member or viewer: 1 on Free, 5 on Growth, unlimited on Pro. On-call rotation, Slack mentions and PagerDuty come with Growth and Pro. ## How Relia compares (checked 24 October 2026 against each product's own pages) ### Relia vs Sentry (https://tryrelia.com/compare/sentry) Error tracking and performance tooling for developers, with an AI that can open pull requests. - First paid plan: Relia, $19 a month; Sentry, $29 a month - AI: Relia, Included in Growth and Pro; Sentry, $40 per active contributor a month - Your code: Relia, Never touched; Sentry, Pull requests when you ask ### Relia vs Datadog (https://tryrelia.com/compare/datadog) A full observability platform priced per product, per host and per volume. - Pricing: Relia, $19 a month, flat; Datadog, From $15 per host a month, each product priced separately - Free plan: Relia, 250,000 units, 5 uptime monitors; Datadog, Infrastructure on up to 5 hosts - AI: Relia, Included in Growth and Pro; Datadog, $1 per AI credit (annual), $1.30 on demand ### Relia vs Better Stack (https://tryrelia.com/compare/better-stack) Uptime, status pages and on-call, with logs, traces and error tracking alongside. - First paid plan: Relia, $19 a month; Better Stack, $34 per responder a month - AI: Relia, Included in Growth and Pro; Better Stack, Billed per million tokens - Your code: Relia, Never touched; Better Stack, Opens pull requests for new exceptions ### Relia vs New Relic (https://tryrelia.com/compare/new-relic) A full observability platform with 100 GB of free data a month, priced by users and data. - Pricing: Relia, $19 a month, flat; New Relic, $99 per additional full user, plus data - Free plan: Relia, 250,000 units, 5 uptime monitors; New Relic, 100 GB of data, 1 full user - Your code: Relia, Never touched; New Relic, Pull requests via GitHub Copilot ### Relia vs Grafana Cloud (https://tryrelia.com/compare/grafana-cloud) Hosted Prometheus, Loki and Tempo with dashboards, on-call and synthetic checks, priced by usage. - Pricing: Relia, $19 a month, flat; Grafana Cloud, $19 a month, plus usage per signal - AI: Relia, Included in Growth and Pro; Grafana Cloud, $20 per active AI user a month - Your code: Relia, Never touched; Grafana Cloud, Pull requests, in public preview ### Relia vs PostHog (https://tryrelia.com/compare/posthog) Product analytics with session replay, error tracking and logs, priced by usage per product. - Uptime and status page: Relia, Both included; PostHog, None found in its docs - Pricing: Relia, $19 a month, flat; PostHog, $0 base, then per use for each product - Your code: Relia, Never touched; PostHog, $15 per AI pull request, in open beta ### Relia vs the DIY stack (https://tryrelia.com/compare/diy-stack) - Errors and tracing: Sentry Team, $26 a month billed annually - Uptime checks and status page: UptimeRobot Solo, $9 a month billed annually - Together: $35 a month. Relia Growth: $15 a month billed annually. ## Documentation (https://tryrelia.com/docs) ### What Relia is > Relia watches your live app and tells you, in plain words, what broke, who it hit and how to fix it, before your customers tell you. Section: Start here · Page: https://tryrelia.com/docs/what-is-relia · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/EUwMvrKf860 Most teams find out their app is broken when a customer complains. Relia watches your product in production and tells you first. #### What Relia watches Relia looks at your whole product, not one log file: | Part | What Relia sees | |---|---| | **Users** | Visits, clicks, page changes, errors in the browser and page speed. What people type is never sent. | | **APIs** | Every request to your server: errors, response times and volume per route. | | **Database** | Failing and slow queries, and repeated queries (N+1). Values in queries are masked before they leave your app. | | **Servers** | CPU, memory and disk on each machine. | | **Uptime & checks** | Your site from the outside, and checks Relia runs on your important pages. | | **AI in your product** | Model calls, tool calls, failures and cost, if your app uses OpenAI, Anthropic, Gemini or similar. | #### What Relia tells you When something goes wrong, Relia groups everything that belongs together (the failing API, the error behind it, the people who hit it, the deploy just before) into one **incident**: - **What happened**, in plain words, with every number linked to its evidence. - **Who it hit**: how many people, and which customers if you tell Relia who your users are. - **Why Relia thinks so**: the chain from cause to symptom. - **What to do next**: one clear action, and on paid plans a fix plan with the exact file and change. After you deploy a fix, Relia watches real traffic and tells you **"Your fix worked"** or **"Still happening"**. #### What Relia does not do - It does not change your code or open pull requests. Your AI assistant can change code with your approval, using what Relia found. - It does not record screens by default. It learns from clicks, pages and errors. - It does not alert you for everything. Things that are normal for your app (a nightly job, a page that is meant to return 404) are learned and kept quiet. #### How you use it 1. **Set it up once**: one command, or one sentence to your AI assistant. See [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md). 2. **Read Home**: one sentence tells you whether your app is OK, and what needs you. 3. **Get told when something breaks**: by email, Slack, ClickUp, Jira or PagerDuty, with a daily summary if you want one. 4. **Ask from your editor**: Claude Code, Cursor, Codex and other AI assistants can read Relia directly. See [Connect your AI assistant](https://tryrelia.com/docs/connect-ai-assistant.md). #### Plans Every new account gets 14 days of Pro, with no card needed. After that you keep the Free plan, which finds problems and emails you a one-line alert. Growth and Pro add the full explanation, fix plans and more. See [pricing](/pricing). #### Next - [Create your account](https://tryrelia.com/docs/create-account.md) - [Try the live demo](https://app.tryrelia.com/demo): a real project, read-only, no sign-up. ### Create your account > Sign up with GitHub, Google or email, answer two questions and confirm your email. Every new account gets 14 days of Pro, no card needed. Section: Start here · Page: https://tryrelia.com/docs/create-account · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/si2whGb2SSs #### Sign up 1. Open [app.tryrelia.com/signup](https://app.tryrelia.com/signup). 2. Choose **GitHub**, **Google** or email. 3. For email: type your name, your work email and a password, tick the box to agree to the terms, and click **Create account**. > **Tip:** a phrase of a few words makes a stronger password than symbols. Relia refuses common and breached passwords. #### Answer two questions Relia asks your **role** and your **team size**, and uses them to choose sensible defaults. Pick one of each and click **Continue**. The next step offers to let your AI assistant set Relia up in your app. You can do that now, or click **Skip for now** and come back to it. See [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md). #### Confirm your email If you signed up with email, a banner at the top asks you to verify your email within 7 days. Open the email from Relia and click **Confirm email**. The link works for one hour; you can ask for a new one from the banner. If you signed up with GitHub or Google, your email is already verified. #### Your trial Every new account gets **14 days of Pro**, and no card is needed. The days left show at the bottom of the sidebar. When the trial ends you keep the **Free** plan; nothing is charged unless you choose a paid plan. #### Check it worked - You see Relia's Home page with your trial shown at the bottom of the sidebar. - After confirming, the verification banner is gone. #### If something's wrong - **No email arrived:** check spam, then use the banner to send it again. - **The link expired:** it works for one hour. Ask for a new one from the banner. #### Next - [Connect your AI assistant](https://tryrelia.com/docs/connect-ai-assistant.md) - [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md) ### A tour of Relia > Know where everything is in Relia before you set anything up, from the menu and the coloured dots to Home, Ask Relia and Settings. Section: Start here · Page: https://tryrelia.com/docs/tour-of-relia · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/xdjhnok11dY This page shows you around the Relia app, so you know where to look once your data arrives. There's nothing to set up here. To look around a real project first, open the live demo at `https://app.tryrelia.com/demo`: it's Northwind, an online shop with live traffic. #### The menu The menu on the left has three parts. At the top: - **Home**: where you start every day. A red number next to it counts the things that need you. - **Ask Relia**: ask questions about your app in plain words. - **Dashboards**: charts Relia builds for your services and pages, and dashboards you make yourself. - **Map**: how your services, databases and outside APIs call each other. - **People**: the signed-in users of your app, once you [tell Relia who they are](https://tryrelia.com/docs/identify-users.md). Under **Your product** there is one entry for each part of your app: | Entry | What it covers | |---|---| | **Users** | Visitors, sessions, page speed, user flows, funnels and UX issues | | **APIs** | The requests your server answers, its logs, performance and errors | | **Database** | Queries, slow ones and N+1 patterns | | **Servers** | CPU, memory and disk per host | | **Uptime & checks** | Your uptime monitors and the checks Relia runs | | **Status page** | Your public status page | | **AI in your product** | Model calls, tool calls and your MCP server | You only see the parts your project sends data for. A web app with no server, for example, has no **APIs** or **Database** entry. Under **Relia** you find **What Relia learned**, **Relia health** and **Teach Relia**. #### What the coloured dots mean Each part of your product has a dot next to it: - **Green**: normal. - **Amber**: worth a look. - **Red**: needs you. The same colour shows on Home and at the top of each part's page, where Relia's verdict for that part comes first, before the charts and tables. #### Home Home is where you start. The large line at the top is Relia's verdict, such as "All good." or "One thing needs you." - **For you** lists what needs you, most important first, each with what to do next. Questions Relia wants you to answer appear here too. - **Worth watching** lists things that are not urgent yet. - **Your product right now** gives one line per part of your product, with its state. > **Tip:** watch [Is my app OK? Read Relia's Home page in 30 seconds](https://youtu.be/BAdQtGBxezQ) (2 min). #### Ask Relia **Ask Relia** answers questions about your app in plain words, such as "Why is checkout failing?" or "Which pages are slowest?". Type your own question or pick a suggestion. Suggestions come from your project's current state. Every answer links to the evidence it used. > **Tip:** watch [Ask your production data questions in plain English (Ask Relia)](https://youtu.be/z3LCOFL7T_U) (2 min). #### Settings **Settings**, at the bottom of the menu, opens your project's settings in four tabs: - **Setup**: your services, and a checklist of what Relia receives. Each row says *Arriving*, *Not yet* or *Optional*. **Setup Guide & SDK** opens the setup steps for every stack, with your project's id and key filled in. - **Notifications**: how Relia reaches you (email, Slack, ClickUp, Jira) and how often. - **Team & plan**: members, roles, your plan and usage. - **Advanced**: autonomy, integrations, SDK settings, data cleanup, the audit log and the danger zone. Below **Settings** is **Help & support**. #### Next - [Connect your AI assistant](https://tryrelia.com/docs/connect-ai-assistant.md) - [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md) - [Read Relia's Home page](https://tryrelia.com/docs/home.md) - [Ask Relia](https://tryrelia.com/docs/ask-relia.md) ### Connect your AI assistant (MCP) > One command connects Relia to Claude Code, Cursor, VS Code, Windsurf, Codex, Antigravity and Gemini CLI, so you can ask what's broken from your editor. Section: Start here · Page: https://tryrelia.com/docs/connect-ai-assistant · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/fpGlCkJzzKA Relia has an MCP server: a standard way for AI assistants to read tools like Relia. Once connected, you can ask your assistant "what needs my attention?", "why is /orders failing?" or "fix the most important problem", and it answers from Relia's evidence. You set this up **once per person**. One connection covers every Relia project you can see. #### Before you start - A Relia account ([Create your account](https://tryrelia.com/docs/create-account.md)). - Node.js on your computer, or Python with `uv` (see below). #### Connect every AI tool at once In a terminal: ```bash npx -y relia-sdk@latest mcp install ``` No Node.js? With Python: ```bash uvx --from relia-sdk@latest relia mcp install ``` It finds the AI tools on your computer and adds Relia to each one, keeping your other settings: **Claude Code, Cursor, VS Code, Windsurf, Codex** (CLI, IDE extension and desktop app), **Antigravity** (IDE and CLI) and **Gemini CLI**. Restart those tools. The first time each one opens a browser: sign in to Relia, see which tool is asking, choose all projects or only some, and click **Allow**. There is no token to copy. #### Claude Desktop and claude.ai Open **Settings → Connectors → Add custom connector** and paste Relia's MCP address: ```text https://devreliaapi.tryrelia.com/mcp ``` Then sign in when asked. #### Add Relia to one tool by hand Your Relia **Profile** (bottom of the menu) has a card, **Use Relia in your AI assistants**, with the exact line for each tool. For example, Claude Code: ```bash claude mcp add --transport http relia https://devreliaapi.tryrelia.com/mcp --scope user ``` Then type `/mcp`, pick **relia** and choose **Authenticate**. Any other MCP tool: give it the address above; it asks you to sign in. #### Tokens for CI and scripts For a script, CI, or a tool that can't sign in, create a token from the same Profile card (**Use a token**; it is shown once), then: ```bash npx -y relia-sdk@latest mcp install --token ``` or set `RELIA_MCP_TOKEN`. Keep the token private, like a password. #### Check it worked Ask your assistant: ```text Use Relia: what needs my attention? ``` It should answer from your Relia project in plain words. To see where Relia is set up: ```bash npx relia-sdk@latest mcp status ``` #### What your assistant can and can't do - **It reads**: what needs you, incidents, fix plans, dashboards, funnels, requests, logs, visits, database queries, page speed and uptime. - **It asks you first** before anything that writes: marking a fix, giving a verdict on an incident, acknowledging an alert, recording a deploy, or creating a project. Relia refuses these without your confirmation, and each one is in the project's audit log. - **It can't** change settings, delete data or see passwords. The full list of tools is in [MCP tools](https://tryrelia.com/docs/mcp-tools.md). #### If something's wrong - **The tool doesn't list Relia:** restart it after `mcp install`. - **"Sign-in required" or a 401:** sign in again from the tool (in Claude Code: `/mcp` → relia → Authenticate). - **Remove it everywhere:** `npx relia-sdk@latest mcp uninstall`. #### Next - [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md) ### Set up Relia with your AI assistant > Ask your AI assistant to "Set up Relia in this repository". It reads your code, asks you two questions, shows every change before writing, and checks that data arrives. Section: Start here · Page: https://tryrelia.com/docs/setup-with-ai-assistant · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/_e0n2r1ZCq4 This is the fastest way to set Relia up: your AI assistant (Claude Code, Cursor, Codex, VS Code and others) does the work in your editor, and you approve each change. #### Before you start - A Relia account ([Create your account](https://tryrelia.com/docs/create-account.md)). - Relia connected to your AI assistant ([Connect your AI assistant](https://tryrelia.com/docs/connect-ai-assistant.md)). - Your app's repository open in the editor. #### Steps 1. **Ask your assistant:** ```text Set up Relia in this repository ``` 2. **Pick or create the project.** If you have several Relia projects, the assistant picks the one for this code or asks you. If the app has no project yet, it asks whether to create one. Nothing is created until you say yes. 3. **Answer two questions.** - *Record screen replays?* Usually **no**. Relia learns from clicks, pages and errors and doesn't need recordings. - *Tell Relia who your users are?* Usually **yes**, so incidents can say which customers were hit. See [Identify your users](https://tryrelia.com/docs/identify-users.md). 4. **Review the changes.** The assistant reads your code (for example an Express API and a React app), then shows every file it will add or change before it writes anything. 5. **Run one command yourself** for readable browser errors: ```bash npx relia-sdk@latest token ``` It creates an **upload-only** token so error stack traces map back to your real files and lines. It is written to `.env.local` as `RELIA_TOKEN` and your assistant never sees it. 6. **When you deploy**, copy the Relia values from `.env.local` into your hosting settings (environment variables on Vercel, Render, Railway and so on). #### Check it worked Start your app and click around, then ask: ```text Check my Relia setup ``` The assistant reports what has arrived: requests, visits, source maps and signed-in users. The same checklist turns green on your project's **Setup** tab in Relia. The first data usually shows within a minute. #### What to do next - **[Teach Relia](https://tryrelia.com/docs/teach-relia.md)** what your product does and what must never break, like checkout. Problems there go straight to the top. - **[Choose how Relia reaches you](https://tryrelia.com/docs/notifications.md)**: urgent problems right away, plus a short daily summary. Add Slack if your team lives there. - From now on, ask your assistant **"what needs me?"**, **"how do I fix it?"**, and after deploying a fix, **"mark it fixed"** so Relia confirms it on real traffic. #### If something's wrong - **Nothing arrives after a few minutes:** see [Relia shows no data](https://tryrelia.com/docs/no-data.md). - **Your assistant can't reach Relia:** see [Connect your AI assistant](https://tryrelia.com/docs/connect-ai-assistant.md#if-somethings-wrong). #### Instructions for AI assistants If you are an AI assistant setting Relia up for a user, follow this order: 1. Connect to Relia's MCP server (`https://devreliaapi.tryrelia.com/mcp`, OAuth sign-in) if it isn't connected. Ask the user to run `npx -y relia-sdk@latest mcp install` if needed. 2. Call `relia_projects`. Use the project whose id is in this repository (`RELIA_PROJECT_ID` in `.env.local`, or `project_id` in `src/relia.ts` / `relia.tracing.js`). If there is none, ask the user whether to use an existing project or create one with `relia_create_project` (only after they say yes, with `confirm: true`). 3. Call `relia_setup` with the project. It returns this project's exact steps for the code in the repository, including its id and ingest key. 4. Ask the user the two questions from `relia_setup` (screen replays, identifying users) before changing anything. 5. Show every change before writing it. Never commit on the user's behalf. 6. Never ask for, read or print the upload token. The user runs `npx relia-sdk@latest token` themselves. 7. After the user has started the app and used it, call `relia_check_setup` and report what has arrived and what is left. Without MCP, the same setup runs from a terminal with `npx relia-sdk@latest init` (Node.js and browser apps) or `pip install relia-sdk` then `python -m relia` (Python). For other stacks see [Set up your stack](/docs#set-up-your-stack). ### Set up Relia in a Node.js or Express app > One command adds Relia to a Node.js server (Express, Fastify, NestJS, Koa, Hapi, Hono) so its requests, errors and database calls show up in Relia. Section: Set up your stack · Page: https://tryrelia.com/docs/node-express-setup · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/ssyz73SYNQ0 This page sets Relia up by hand from a terminal. To have your AI assistant do it instead, see [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md). #### Before you start - A Relia account ([Create your account](https://tryrelia.com/docs/create-account.md)). - A terminal open in your server's folder (the one with its `package.json`). #### Steps 1. **Run the setup:** ```bash npx relia-sdk@latest init ``` Always use `relia-sdk`: the npm package called `relia` belongs to someone else. 2. **Sign in.** Choose the browser option, copy the token from the **CLI Authentication** page, and paste it back into the terminal. 3. **Choose what to set up.** The setup finds your server framework (for example *Express API*). Choose **Everything Relia found here**. 4. **Pick your Relia project**, or create one right there. 5. **Answer "Tell Relia who your users are?"** Say yes if your app has sign-in. The setup then prints the lines to add; see [Identify your users](https://tryrelia.com/docs/identify-users.md). > **Tip:** watch [See which customers a bug hit: identify users in Relia](https://youtu.be/1mIOiHnI9nk) (2 min). 6. **Check what it wrote:** - A new `relia.tracing.js` with your project's id and key. - One line at the top of your entry file (the file `npm start` runs) that loads it first, for example `require('./relia.tracing');` (the path depends on where your entry file is). - For Express: Relia's middleware after `const app = express()`, and its error handler after your routes. - `relia-sdk` added to your `package.json`. 7. **Restart your app** and call one of its endpoints. The console says `tracing initialized`. #### Set it up by hand instead If you'd rather write the code yourself, install the package: ```bash npm install relia-sdk ``` Create `relia.tracing.js` (your project's id and key are on your project page under **Setup Guide & SDK**): ```js require("relia-sdk/node").start({ serviceName: "my-api", projectId: "", key: "", }) ``` Load it as the very first line of your entry file, before any other import: ```js require("./relia.tracing") // ESM: import "./relia.tracing.js" ``` For Express, add the middleware and the error handler: ```js const relia = require("relia-sdk/node") app.use(relia.expressMiddleware()) // ... your routes ... app.use(relia.expressErrorHandler()) // after your routes: records errors with their stack trace ``` #### What Relia records - Every request with its route, status and time: Express, Fastify, NestJS, Koa and Hapi. - Errors with their stack traces. - Outgoing HTTP and `fetch` calls. - Database calls (PostgreSQL, MongoDB, MySQL, Redis), with values removed. - Queue jobs (BullMQ, SQS, Kafka) and GraphQL. - Warnings and errors from `console.warn`, `console.error`, winston and bunyan, as log lines. Set `RELIA_LOGS=0` to turn this off. - Calls to AI models in your product. See [Monitor AI calls in your app](https://tryrelia.com/docs/ai-calls-setup.md). Running several services in one project? Give each its own `serviceName`. Relia draws how they call each other on the **Map**. #### When you deploy Your project's id and key are inside `relia.tracing.js`, so your host needs no extra environment variable. Just deploy as usual. #### Check it worked Open your project in Relia and go to the **Setup** tab. **Requests from your server** changes from *Not yet* to *Arriving*, usually within a minute. Your requests and errors appear under **APIs**, and your queries under **Database**. #### If something's wrong - **Still "Not yet" after a few minutes:** make sure `relia.tracing` is loaded before anything else in your entry file, restart the app and call an endpoint again. Then see [Relia shows no data](https://tryrelia.com/docs/no-data.md). - **Errors show without a stack trace (Express):** `expressErrorHandler()` must come after your routes. - **The setup refused to create a project:** it shows the reason and offers your existing projects. Pick one of them. #### Next - [Identify your users](https://tryrelia.com/docs/identify-users.md) - [Watch your web app](https://tryrelia.com/docs/web-app-setup.md) - [Teach Relia what matters](https://tryrelia.com/docs/teach-relia.md) - [Set up a Next.js app](https://tryrelia.com/docs/nextjs-setup.md) ### Set up Relia in a Next.js app > One command adds Relia to a Next.js app, including apps deployed on Vercel. It writes instrumentation.ts and records every server request with Next's own route names. Section: Set up your stack · Page: https://tryrelia.com/docs/nextjs-setup · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/v97-F6jftRE This page sets Relia up by hand from a terminal. To have your AI assistant do it instead, see [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md). #### Before you start - A Relia account ([Create your account](https://tryrelia.com/docs/create-account.md)). - A terminal open in your Next.js app's folder. #### Steps 1. **Run the setup:** ```bash npx relia-sdk@latest init ``` Always use `relia-sdk`: the npm package called `relia` belongs to someone else. 2. **Sign in.** Choose the browser option, copy the token from the **CLI Authentication** page, and paste it back into the terminal. 3. **Choose what to set up.** It detects your Next.js app. Choose **Everything Relia found here** (your Next.js server, plus AI SDK calls if your app uses the Vercel AI SDK), or pick one kind. 4. **Pick your Relia project**, or create one right there. 5. **Check what it wrote:** - A new `instrumentation.ts` (inside `src/` when your app lives there). It starts Relia on your server, with your project's id and key inside. - `relia-sdk` added to your `package.json`. - The browser side is a separate choice: run the setup again and choose **Session & User journey monitoring**. See [Watch your web app](https://tryrelia.com/docs/web-app-setup.md). > **Note:** if you already have an `instrumentation.ts`, it is left alone and the lines to add are printed instead. 6. **Next.js 13 or 14 only:** turn the instrumentation hook on in `next.config`: ```js experimental: { instrumentationHook: true } ``` 7. **Restart your app** and open a page or call one of its API routes. The console says `tracing initialized`. #### Deploying on Vercel Nothing to add. Serverless mode switches on by itself, and your project's id and key are already inside `instrumentation.ts`, so the server needs no extra environment variable. #### What Relia records - One entry per request, with Next's own route name, for example `GET /api/orders/[id]`. - Errors with stack traces that point at your source files (for example `app/api/orders/[id]/route.ts:9`), not compiled `.next` chunks. - Outgoing calls (fetch) and database calls inside each request. - Calls made with the Vercel AI SDK (`streamText`, `generateText`), with no code change. See [Monitor AI in your product](https://tryrelia.com/docs/ai-in-your-product.md). #### Check it worked Open your project in Relia and go to the **Setup** tab. **Requests from your server** changes from *Not yet* to *Arriving*, usually within a minute. Your requests and errors appear under **APIs**. #### If something's wrong - **Still "Not yet" after a few minutes:** restart the app once more, then see [Relia shows no data](https://tryrelia.com/docs/no-data.md). - **Next.js 13 or 14 and nothing arrives:** check the `instrumentationHook` setting from step 6. #### Next - [Identify your users](https://tryrelia.com/docs/identify-users.md) - [Teach Relia what matters](https://tryrelia.com/docs/teach-relia.md) ### Set up Relia in a Python app > Add Relia to a FastAPI, Django or Flask app with one command, so its requests, errors and database calls show up in Relia. Section: Set up your stack · Page: https://tryrelia.com/docs/python-setup · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/T7V5zFjMhjg This page sets Relia up by hand from a terminal. To have your AI assistant do it instead, see [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md). #### Before you start - A Relia account ([Create your account](https://tryrelia.com/docs/create-account.md)). - Python 3.9 or newer. - A terminal open in your app's folder, with your app's virtual environment active. #### Steps 1. **Install the package and run the setup:** ```bash pip install relia-sdk relia init ``` `python -m relia` runs the same setup if the `relia` command isn't on your path. 2. **Sign in.** Choose the browser option, copy the token from the **CLI Authentication** page, and paste it back into the terminal. 3. **Choose what to monitor:** **API & Request APM (FastAPI / Flask / Django)**. 4. **Pick your Relia project**, or create one right there. Then pick a service, or create one. The service is the name your app shows under in Relia. 5. **Check what it wrote:** - Your `.env` gets `RELIA_PROJECT_ID`, `RELIA_KEY`, `RELIA_SERVICE_NAME` and `RELIA_OTLP_ENDPOINT`. - A new file, `relia_tracing.py`, starts Relia. - **FastAPI:** your entry file (for example `main.py`) gets two lines at the top that start Relia, and one line right after `app = FastAPI(...)`. - **Flask:** `ReliaFlask(app)` is added after your app is created. - **Django:** `relia.integrations.django.ReliaDjangoMiddleware` goes first in `MIDDLEWARE`, in `settings.py`. 6. **Answer "Tell Relia who your users are?"** Say yes if your app has sign-in. The setup prints the line to add; see [Identify your users](https://tryrelia.com/docs/identify-users.md). > **Tip:** watch [See which customers a bug hit: identify users in Relia](https://youtu.be/1mIOiHnI9nk) (2 min). 7. **Start your app** (for example with `uvicorn`) and call one of its endpoints. > **Tip:** for the framework's own request tracing, install the matching extra: `pip install "relia-sdk[fastapi]"`, `"relia-sdk[flask]"` or `"relia-sdk[django]"`. #### Set it up by hand instead At the very top of your entry module, before your framework is imported: ```python import relia relia.start(project_id="", service_name="my-api") ``` Then, depending on your framework: ```python ### FastAPI: after app = FastAPI() from relia.integrations.fastapi import instrument_fastapi instrument_fastapi(app, project_id="", service_name="my-api") ### Flask: after app = Flask(__name__) from relia.integrations.flask import ReliaFlask ReliaFlask(app) ``` For Django, add `"relia.integrations.django.ReliaDjangoMiddleware"` first in `MIDDLEWARE`. Put your project key in the server's environment as `RELIA_KEY`. Your project's id and key are on your project page under **Setup Guide & SDK**. #### What Relia records - Every request with its route template (`/orders/{id}`, never one row per id), status and time. - Errors with their stack traces. - Outgoing calls made with `requests`, `httpx` and `aiohttp`. - Database calls (PostgreSQL, MySQL, MongoDB, Redis, SQLAlchemy), with values removed. - Celery tasks and AWS calls. - Log records at WARNING and above. `RELIA_LOG_LEVEL` changes the level; `RELIA_LOGS=0` turns logs off. - Calls to AI models in your product. See [Monitor AI calls in your app](https://tryrelia.com/docs/ai-calls-setup.md). #### Settings | Variable | What it does | Default | |---|---|---| | `RELIA_PROJECT_ID` | Your project id | none | | `RELIA_KEY` | Your project key | none | | `RELIA_SERVICE_NAME` | The name your app shows under in Relia | `backend` | | `RELIA_ENV` | Environment label | `production` | On your laptop, set `RELIA_ENV=development` so test traffic stays apart from production. #### When you deploy Copy the `RELIA_*` lines from `.env` into your host's environment variables (Render, Railway, Fly, a Dockerfile and so on). #### Check it worked Open your project in Relia and go to the **Setup** tab. **Requests from your server** changes from *Not yet* to *Arriving*, usually within a minute. Your requests and errors appear under **APIs**, and your queries under **Database**. #### If something's wrong - **Still "Not yet" after a few minutes:** make sure Relia starts before your framework is imported (the lines must be at the very top of the entry file), restart and call an endpoint again. Then see [Relia shows no data](https://tryrelia.com/docs/no-data.md). - **The setup couldn't patch your entry file:** it prints the lines to add. Add them by hand as shown above. - **Django middleware missing:** the setup looks for `settings.py` in common places. If yours is elsewhere, add the middleware line yourself. #### Next - [Identify your users](https://tryrelia.com/docs/identify-users.md) - [Watch your web app](https://tryrelia.com/docs/web-app-setup.md) - [Teach Relia what matters](https://tryrelia.com/docs/teach-relia.md) ### Set up Relia in a Laravel or PHP app > Add Relia to a Laravel app with one Composer package and one artisan command, or to plain PHP with two lines. No PHP extension needed. Section: Set up your stack · Page: https://tryrelia.com/docs/laravel-php-setup · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/ZExvI3df3sE Relia's PHP package is pure PHP. It needs no PHP extension, so it also works on shared hosting and cPanel. To have your AI assistant do the setup instead, see [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md). #### Before you start - A Relia account ([Create your account](https://tryrelia.com/docs/create-account.md)). - PHP 8.1 or newer, and Composer. - Your project's id and key. In Relia, open your project and click **Setup Guide & SDK**, then pick **PHP / Laravel**. The code shown there already holds your id and your key (the key starts with `relia_live_`). #### Steps (Laravel) 1. **Install the package** in your Laravel app's folder: ```bash composer require tryrelia/relia ``` 2. **Write the settings:** ```bash php artisan relia:install ``` It asks for your project id, then your project key. Paste each one and press Enter. The **PHP / Laravel** card in the setup guide also shows this command with `--project`, `--key` and `--service` already filled in, so you can paste it instead. 3. **Check `.env`.** It now has three lines: `RELIA_PROJECT_ID`, `RELIA_KEY` and `RELIA_SERVICE_NAME`. There's no middleware or provider to add: Laravel picks the package up by itself. 4. **Add the browser part** (visitors, page speed and browser errors). Put this in your main Blade layout, just before ``: ```blade @reliaScript ``` If your app uses Vite, `relia:install` prints the lines to add to `resources/js/app.js` instead. 5. **Start your app and open any page.** > **Tip:** if you have Node.js, `npx relia-sdk@latest init` in a Laravel app does all of this for you: it installs the Composer package, writes the `RELIA_*` lines to `.env` and wires the browser part through Vite. #### Steps (plain PHP) 1. **Install the package:** ```bash composer require tryrelia/relia ``` 2. **Start Relia** at the top of your front controller (`public/index.php` or `index.php`), right after ` '', 'serviceName' => 'shop', 'key' => '']); ``` Add the autoloader line only if the file doesn't load Composer yet. From `public/index.php` the path is `__DIR__ . '/../vendor/autoload.php'`. Rather keep the values out of the code? Set `RELIA_PROJECT_ID`, `RELIA_KEY` and `RELIA_SERVICE_NAME` in your host's environment and call `\Relia\Relia::start()` with no arguments. Plain PHP doesn't read a `.env` file, so these must be real environment variables (your web server's or PHP-FPM pool's). #### What Relia records In Laravel, from the next request: - every request with its route (`/orders/{id}`), status and time; - the error behind a 500, with its stack trace; - database queries, with values removed; - calls made with Laravel's HTTP client; - queue jobs; - warning and error log lines; - the signed-in user's id (never the e-mail). To show plans on people ("3 customers on Pro"), see [Identify your users](https://tryrelia.com/docs/identify-users.md). > **Tip:** watch [See which customers a bug hit: identify users in Relia](https://youtu.be/1mIOiHnI9nk) (2 min). In plain PHP: each request, uncaught exceptions and fatal errors. To time a slow part on its own: ```php \Relia\Relia::measure('charge card', fn () => $gateway->charge($order)); ``` The data is sent after the response, so visitors never wait for it (PHP-FPM and LiteSpeed). PHP's built-in server (`php artisan serve`, `php -S`) can't send the page first, so there each request waits a moment for the send. That's normal in development. #### Settings All optional, in `.env`: | Variable | What it does | |---|---| | `RELIA_SERVICE_NAME` | The name shown in Relia (default: your app's name) | | `RELIA_ENV` | `development` on your laptop, so test traffic stays apart (default: Laravel's `APP_ENV`, else `production`) | | `RELIA_LOGS=false` | Don't send log lines | | `RELIA_LOG_LEVEL=error` | Only send errors | | `RELIA_QUERIES=false`, `RELIA_HTTP_CLIENT=false`, `RELIA_QUEUE=false` | Switch one part off | | `RELIA_RELEASE` | Your version, if Relia can't read it from git or your host | #### When you deploy Add the same `RELIA_*` lines to your host's environment (Forge, Vapor, Laravel Cloud, cPanel and so on). #### Check it worked Open your project in Relia and go to the **Setup** tab. **Requests from your server** changes from *Not yet* to *Arriving*. Your requests and errors appear under **APIs**, and your queries under **Database**. #### If something's wrong - **`relia:install` says the id is wrong:** a project id is 24 letters and digits. Copy it again from the **Setup** tab. - **The key is refused:** a project key starts with `relia_live_`. - **No visits from the browser:** check that `@reliaScript` is in the layout your pages actually use, before ``. - **Still "Not yet":** see [Relia shows no data](https://tryrelia.com/docs/no-data.md). #### Next - [Identify your users](https://tryrelia.com/docs/identify-users.md) - [Teach Relia what matters](https://tryrelia.com/docs/teach-relia.md) - [Choose how Relia reaches you](https://tryrelia.com/docs/notifications.md) ### Watch your web app > Add Relia to a React, Vue, Svelte or other browser app with one command, so visits, errors, broken buttons and page speed show up in Relia. Section: Set up your stack · Page: https://tryrelia.com/docs/web-app-setup · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/-dkUYYsaXNc This page sets up a browser app on its own, for example a React app built with Vite. Using Next.js? Set up its server with [Set up a Next.js app](https://tryrelia.com/docs/nextjs-setup.md); for its browser side, run the setup below and choose **Session & User journey monitoring** (Next.js source maps are not wired by the setup). To have your AI assistant do the setup, see [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md). #### Before you start - A Relia account ([Create your account](https://tryrelia.com/docs/create-account.md)). - A terminal open in your web app's folder (the one with its `package.json`). #### Steps 1. **Run the setup:** ```bash npx relia-sdk@latest init ``` Always use `relia-sdk`: the npm package called `relia` belongs to someone else. 2. **Sign in.** Choose the browser option, copy the token from the **CLI Authentication** page, and paste it back into the terminal. 3. **Choose what to set up.** The setup finds your app (for example *React app (Vite)*). Choose **Everything Relia found here**, then pick your Relia project or create one. 4. **Choose what Relia records in the browser:** - **1) Clicks, pages and errors** (recommended, the default). This is how Relia finds broken buttons, slow pages and stuck visitors. - **2) The same, plus screen replays.** Only lets you watch a session; it records what is on the screen. - **3) Page views only.** Visitor analytics and errors, the cheapest option: 1 unit per page view, no click data. Good for a marketing site. Your file then gets `mode: "pageviews"`. 5. **Answer "Tell Relia who your users are?"** Say yes if your app has sign-in. See [Identify your users](https://tryrelia.com/docs/identify-users.md). 6. **Check what it wrote:** - A new file, `src/relia.ts`, with your project's settings. - Your entry file (for example `src/main.tsx`) imports it first: `import "./relia"`. - Source maps, so browser errors point at your real files: Vite apps get `reliaSourcemaps(...)` in `vite.config`; other bundlers get an upload added to the `build` script. - An upload-only `RELIA_TOKEN` in `.env.local`, which is kept out of git. - `relia-sdk` added to your `package.json`. 7. **Run your dev server, open the app and click around once.** #### What Relia records - Every visit as a journey: pages, clicks, form submits and errors. - Page speed: loading (LCP), responsiveness (INP) and layout shift (CLS). - Browser errors with stack traces mapped back to your source files. - Which API request a click made, so a failing button and a failing API become one problem. The text people type is not captured (`captureText: false`), and nothing is screen recorded unless you set `replay: true`. #### Set it up by hand instead ```bash npm install relia-sdk ``` Create `src/relia.ts` (your project's id and key are on your project page under **Setup Guide & SDK**): ```ts import { Relia } from "relia-sdk" Relia.init({ project_id: "", key: "", service_name: "shop-web", captureText: false, replay: false, }) ``` Import it as the first line of your entry file: ```ts import "./relia" ``` For readable errors with Vite, add the plugin to `vite.config`: ```ts import { reliaSourcemaps } from "relia-sdk/vite" export default { plugins: [reliaSourcemaps({ projectId: "" })] } ``` Then run this once in the app's folder to get the upload-only token: ```bash npx relia-sdk@latest token ``` #### When you deploy Hosted builds (Vercel, Netlify, Render, CI) don't have your `.env.local`. Add `RELIA_TOKEN` with the same value to the host's environment variables. Until you do, builds still succeed; they just skip the source map upload. The maps are removed from the build output either way, so your source code is never published. > **Tip:** watch [Browser errors show minified code? Upload source maps to fix it](https://youtu.be/ArLJuvippU8) (2 min). #### Check it worked Open your project in Relia and go to the **Setup** tab. **Visits to your web app** changes from *Not yet* to *Arriving*. With no server, **Requests from your server** shows *Optional*. **Source maps** follows after your first build. Your visits appear under **Users**: **Visitors**, **Sessions** and **Page speed**. #### If something's wrong - **No visits:** make sure `import "./relia"` is the first line of the entry file your app really loads, then reload the page. See [Relia shows no data](https://tryrelia.com/docs/no-data.md). - **Browser errors show minified code:** the source maps weren't uploaded. Check `RELIA_TOKEN` is set where the build runs. See [Upload source maps](https://tryrelia.com/docs/source-maps.md). - **Lost the token value:** run `npx relia-sdk@latest token` again in the app's folder. #### Next - [Identify your users](https://tryrelia.com/docs/identify-users.md) - [Visitors, sessions and page speed](https://tryrelia.com/docs/users-and-visitors.md) - [Control what Relia collects](https://tryrelia.com/docs/sdk-settings.md) - [Privacy in Relia](https://tryrelia.com/docs/privacy.md) ### Watch a Flutter app > Add Relia to a Flutter app with one package, so sessions, screens, taps, API calls and crashes on Android and iOS show up in Relia, joined to your backend. Section: Set up your stack · Page: https://tryrelia.com/docs/flutter-setup · Last checked against the product: 2026-11-19 Relia watches your Flutter app the way it watches your website: what people did, what broke, and which API call came just before it. When a backend change breaks one version of your app, the incident shows both sides. To have your AI assistant do the setup instead, see [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md). #### Before you start - A Relia account ([Create your account](https://tryrelia.com/docs/create-account.md)). - A Flutter app (Flutter 3.19 or newer). - Your project's id and key. In Relia, open your project and click **Setup Guide & SDK**, then pick **Flutter**. The code shown there already holds your id and your key (the key starts with `relia_live_`). #### Steps 1. **Install the package** in your app's folder: ```bash flutter pub add relia_flutter ``` Or run `npx relia-sdk@latest init` there: it finds the Flutter app, adds the package and edits `lib/main.dart` for you. 2. **Start Relia in `lib/main.dart`**, before `runApp`: ```dart import 'package:flutter/material.dart'; import 'package:relia_flutter/relia_flutter.dart'; Future main() async { WidgetsFlutterBinding.ensureInitialized(); await Relia.init(const ReliaOptions(projectId: 'your-project-id', key: 'relia_live_…', serviceName: 'shop-app')); runApp(Relia.wrap(const MyApp())); } ``` Start it before the app creates its HTTP clients: every call made with the `http` package, dio or `HttpClient` after it is recorded, with no other change. 3. **Name your screens.** Add the observer to your app: ```dart MaterialApp(navigatorObservers: [Relia.navigatorObserver], …) // or with go_router GoRouter(observers: [Relia.navigatorObserver], …) ``` A screen is the route's **name**, never its arguments, so give your routes names. 4. **See a crash arrive.** Add a button that calls `Relia.testCrash()`, press it, and open **Mobile app** in Relia. The crash is there within a minute, with the steps that led to it. Remove the button afterwards. #### What counts as a crash A widget that fails to build or draw shows the person a broken screen, so it counts against **crash-free people**. Other errors your app didn't catch (a failed call in the background, an image that didn't load) are listed as crash groups too, but don't lower crash-free people. On Android, Relia also catches what happens outside Dart: a Java or Kotlin exception (often from a plugin), the app freezing ("app not responding"), a native crash, and Android closing the app for memory. These arrive the next time the app is opened, with the screen and the steps before them. Nothing to set up. #### Readable crashes A normal `flutter build` keeps your function names and lines, so a crash points at `lib/…:line` straight away, with nothing to upload. Builds made with `--obfuscate --split-debug-info` print addresses only, which Relia can't read yet. #### Join the app to your backend ```dart ReliaOptions(projectId: 'your-project-id', key: 'relia_live_…', propagateTo: ['api.yourdomain.com']) ``` Calls to the hosts you list carry a `traceparent` header, so one incident shows the phone and the server. Third-party APIs never get it. #### Who your users are After sign-in: `Relia.identify(user.id, {'email': user.email, 'name': user.name, 'plan': user.plan})`. On sign-out: `Relia.reset()`. Nothing about the person is sent without it. #### What it records - **Screens:** the route's name. Dialogs and bottom sheets are not screens. - **Taps:** the button's Key, else its tooltip or label, else its widget type. Its text only with `captureText: true`, and never from a text field. - **API calls:** method, address without its query, status and duration. Calls that fail because the phone was offline, or that the app cancelled, are never counted as failures. - **Your app's version and build**, the phone model, system version and network type. It never records typed text, screen pixels, a URL's query or an advertising id. Your own error handlers, Crashlytics and Sentry keep working: Relia passes every error on. #### What it costs **300 units per device per month.** Each phone or tablet that opens your app counts once in a calendar month, however many times it is used that month. Crashes are free. See [Plans and billing](https://tryrelia.com/docs/plans-and-billing.md). #### Not yet Native iOS crashes and the app start time on iOS. Sessions, screens, taps, API calls and Dart crashes already work on iOS. ### Watch a React Native or Expo app > Add Relia to a React Native or Expo app, so sessions, screens, taps, API calls and crashes show up in Relia, joined to your backend, with readable crash stacks from release builds. Section: Set up your stack · Page: https://tryrelia.com/docs/react-native-setup · Last checked against the product: 2026-11-19 > **Available from Monday 23 November.** The `relia-react-native` package goes live then. Flutter apps can be set up today: [Watch a Flutter app](https://tryrelia.com/docs/flutter-setup.md). Relia watches your mobile app the way it watches your website: what people did, what crashed, and which API call came just before it. When a backend change breaks one version of your app, the incident shows both sides. To have your AI assistant do the setup instead, see [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md). #### Before you start - A Relia account ([Create your account](https://tryrelia.com/docs/create-account.md)). - A React Native app (0.72 or newer) or an Expo app. - Node.js, to run the setup command. #### Steps 1. **Run the setup** in your app's folder: ```bash npx relia-sdk@latest init ``` It finds Expo or bare React Native, installs `relia-react-native`, writes `relia.ts`, wraps your root component and sets up your release builds to upload their symbols. 2. **Or by hand**, the two lines that matter: ```ts import { Relia } from "relia-react-native" Relia.init({ projectId: "your-project-id", key: "relia_live_…" }) export default Relia.wrap(App) ``` - **Expo Router:** wrap your root layout (`app/_layout.tsx`); screens are named by their route. - **React Navigation:** also call `Relia.watchNavigation(navigationRef)` once, next to where the ref is created. 3. **See a crash arrive.** In a development build (`npx expo run:android` or an EAS development build; Expo Go has no crash files), add a button that calls `Relia.testCrash()`, press it, and open the app again. The crash shows on **Mobile app** in Relia within a minute. Remove the button afterwards. #### Readable crashes A release build's crash stack is a list of offsets in a bundle until Relia has the build's symbols. Each release build uploads them by itself (the JavaScript source map, and Android's R8 mapping when your build shrinks its code): 1. Expo: add `"relia-react-native"` to `"plugins"` in `app.json`. Bare React Native: `relia init` adds one line to `android/app/build.gradle`. 2. Run `npx relia-sdk@latest token` once in the app's folder. It writes an **upload-only** token to `.env.local`. 3. Add `RELIA_PROJECT_ID` and that `RELIA_TOKEN` to your EAS secrets or CI variables. A failed upload never fails your build. On the project's **Setup** tab, "Symbols" turns green once your newest release has them. #### Join the app to your backend ```ts Relia.init({ projectId: "your-project-id", key: "relia_live_…", propagateTo: ["api.yourdomain.com"] }) ``` Calls to the hosts you list carry a `traceparent` header, so one incident shows the phone and the server. Third-party APIs never get it. #### Who your users are After sign-in (or when a saved sign-in is restored): `Relia.identify(user.id, { email, name, plan })`. On sign-out: `Relia.reset()`. Nothing about the person is sent without it. #### What it records - **Screens:** the route's name or template, never its parameters. - **Taps:** the accessibility label, test id or component name. Text only with `captureText: true`, and never from an input. - **API calls:** method, address without its query, status and duration. Calls that fail because the phone was offline, or that the app cancelled, are never counted as failures. - **Crashes and freezes:** JavaScript crashes, Android crashes, "app not responding" and memory kills, kept on the phone until Relia has them. - **Your app's version and build**, the phone model, system version and network type. It never records typed text, screen pixels, a URL's query or an advertising id. React Native's own error handling, Crashlytics and Sentry keep working. #### App store privacy forms What to declare when your app includes Relia (check it against everything else your app collects): - **Apple (App Privacy):** Crash Data, Performance Data, Other Diagnostic Data and Product Interaction, used for App Functionality and Analytics, not used for tracking. Not linked to identity, unless you call `Relia.identify`: then also User ID (and Email Address or Name if you pass them), linked to the user. - **Google Play (Data safety):** App info and performance (crash logs, diagnostics) and App activity (app interactions), collected, not shared, encrypted in transit. With `Relia.identify`, also Personal info (user IDs, and email address or name if you pass them). #### What it costs **300 units per device per month.** Each phone or tablet that opens your app counts once in a calendar month, however many times it is used that month. Crashes are free. See [Plans and billing](https://tryrelia.com/docs/plans-and-billing.md). #### Not yet Native iOS crashes (outside JavaScript). Sessions, screens, taps, API calls and JavaScript crashes already work on iOS. ### Set up Relia in a Supabase app > Watch a Supabase app in three parts: the web app's table reads and writes, your Edge Functions, and the database's own statistics. Section: Set up your stack · Page: https://tryrelia.com/docs/supabase-setup · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/lgFYplJANic Many Supabase apps talk to the database straight from the browser, with no server of their own. Relia sees those calls too. This page sets up three parts; do the ones your app has. To have your AI assistant do it instead, see [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md). #### Before you start - A Relia account ([Create your account](https://tryrelia.com/docs/create-account.md)). - Your project's id and key, for the Edge Functions part. In Relia, open your project, click **Setup Guide & SDK** and pick **Supabase**: the steps there have your values filled in. #### Steps ##### Part 1: the web app 1. In your web app's folder, run: ```bash npx relia-sdk@latest init ``` 2. Sign in, choose **Everything Relia found here**, pick your project and answer the two questions. The full walkthrough is in [Watch your web app](https://tryrelia.com/docs/web-app-setup.md). That's all `supabase-js` needs. Relia recognizes its calls by itself: - **Every table read and write** appears on the **Database** page: the table, the operation, and the filters **without their values**. `?email=eq.ann@shop.io` is stored as `WHERE email = ?`, and the query string never leaves the browser. - **A write refused by a row level security policy** is named as such, not just shown as a 403. - **Sign-ins and sign-ups** are counted by outcome. - Storage uploads and Edge Function calls show as calls to Supabase. Your Supabase anon key is never stored. ##### Part 2: Edge Functions 1. **Wrap each function's handler** in `supabase/functions//index.ts`. The handler itself stays unchanged: ```ts import { withRelia } from "npm:relia-sdk/edge" Deno.serve(withRelia(async (req) => { // your handler, unchanged })) ``` 2. **Give the functions their settings** once (the same for every function): ```bash supabase secrets set RELIA_PROJECT_ID= RELIA_KEY= RELIA_SERVICE_NAME=shop-functions ``` 3. **Testing locally** with `supabase functions serve`? The local server stops a function right after it answers, which cuts off sending. Add the settings to `supabase/functions/.env`, plus two more lines: ```bash RELIA_PROJECT_ID= RELIA_KEY= RELIA_SERVICE_NAME=shop-functions RELIA_ENV=development RELIA_FLUSH=before ``` Make sure `.gitignore` covers `supabase/functions/.env`. Each call becomes a request named after the function, its `supabase-js` table calls become database calls, and its `fetch` calls become outgoing calls. In production the data is sent after the response, so your users never wait for it. > **Tip:** the same wrapper works on Cloudflare Workers, Vercel Edge and Deno. See [Set up edge runtimes](https://tryrelia.com/docs/edge-runtimes-setup.md). ##### Part 3: inside your database (optional) Relia can also read your database's own statistics: - slow queries as Postgres measures them, including ones no app call shows, like those from scheduled jobs; - scheduled jobs (pg_cron) that fail, and jobs that stop running; - connections running out, and the database's size. 1. In Relia, open **Database** and click **Connect**. 2. Copy the SQL snippet Relia shows and run it once in Supabase's **SQL editor**. It creates a login called `relia_monitor` that can read statistics only and can't see or change your data. The password is made for you and shown only there. No pg_cron? Skip the snippet's last two lines. 3. In Supabase, open **Connect** and copy the **Session pooler** connection string, with the user `relia_monitor` and the password from the snippet. 4. Paste it into Relia and click **Connect**. Relia refuses any login that can read your tables, stores the connection string encrypted, and reads every 5 minutes. If your database has network restrictions on, allow Relia's server first. > **Tip:** watch [Database monitoring for Postgres, MongoDB and Supabase](https://youtu.be/zpZNjfd7mVk) (2 min). #### Linking the web app to a function (optional) To see a browser call and the function it reached as one story, do both: - add `propagateTo: ["*.supabase.co"]` to `Relia.init`; - add `traceparent` to the function's `Access-Control-Allow-Headers`. Do both or neither: without the CORS change, the browser refuses the call. #### Check it worked Open your web app once, and call a function if you set those up. On your project's **Setup** tab, **Visits to your web app** changes from *Not yet* to *Arriving*, and **Requests from your server** too once a function has been called. Your table reads and writes appear under **Database**. #### If something's wrong - **Function calls never arrive when testing locally:** add `RELIA_FLUSH=before` to `supabase/functions/.env`. - **Connect refuses the login:** use the `relia_monitor` login from the snippet, not your admin password. Relia refuses any login that can read or change your tables. - **No table calls on Database:** make sure the web app part is set up and you've used the app once. See [Relia shows no data](https://tryrelia.com/docs/no-data.md). #### Next - [Identify your users](https://tryrelia.com/docs/identify-users.md) - [Database monitoring](https://tryrelia.com/docs/database.md) - [Find slow database queries](https://tryrelia.com/docs/slow-database-queries.md) ### Set up Relia in a Firebase app > Watch a Firebase app: the web app with Firebase errors named in plain words, and your Cloud Functions with their Firestore calls. Section: Set up your stack · Page: https://tryrelia.com/docs/firebase-setup · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/ivBssYQ5dLQ This page sets up a Firebase app in two parts: the web app and Cloud Functions. Do the ones your app has. To have your AI assistant do it instead, see [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md). #### Before you start - A Relia account ([Create your account](https://tryrelia.com/docs/create-account.md)). - A terminal, and your app's repository with its web app folder and its `functions/` folder. #### Steps ##### Part 1: the web app 1. In your web app's folder, run: ```bash npx relia-sdk@latest init ``` 2. Sign in, choose **Everything Relia found here**, pick your project and answer the two questions. The full walkthrough is in [Watch your web app](https://tryrelia.com/docs/web-app-setup.md). With the Firebase JS SDK, Relia then names Firebase's errors in plain words: - `permission-denied`: **blocked by your security rules**. When your rules refuse users, the incident says so and tells you to check your Firestore and Storage security rules. - `resource-exhausted`: **a quota or rate limit was hit**. - `unavailable`, `unauthenticated`, `failed-precondition` (often a missing index), and Auth codes like `invalid-credential`. Sign-ins and sign-ups are counted by outcome. Firestore reads and writes made from the browser travel over a streaming connection that can't be timed one by one, so for those Relia shows the errors, not each query's speed. > **Tip:** watch [Fix JavaScript errors in production with readable stack traces](https://youtu.be/DrD9OWbQ_nQ) (2 min). ##### Part 2: Cloud Functions (Node) 1. Run the same command in your `functions/` folder: ```bash cd functions npx relia-sdk@latest init ``` 2. It finds **Firebase Cloud Functions** by itself. Choose **Everything Relia found here** and pick the same project. 3. **Check what it wrote:** a new `relia.tracing.js`, loaded as the first line of `index.js` (or `src/index.ts`), before `firebase-functions` and `firebase-admin`. To do it by hand instead: run `npm install relia-sdk` in `functions/`, create `functions/relia.tracing.js`: ```js require("relia-sdk/node").start({ serviceName: "shop-functions", projectId: "", key: "", }) ``` and make it the first line of `functions/index.js`: ```js require("./relia.tracing") // TypeScript: import "./relia.tracing" first in src/index.ts ``` Relia notices it runs as a Cloud Function and switches to serverless mode by itself: - each function call becomes a request **named after the function**; - a function that **throws** is recorded as a failed request with its error. It is answered 500, and Firebase still sees the crash as before; - **Firestore calls** made with the Admin SDK become database calls; - the data is sent **before each response**, because Google stops the function's CPU right after it answers. That adds roughly 50 to 200 ms per call, never more than 1 second. If your functions use *CPU always allocated*, set `RELIA_FLUSH=after` to skip the wait. ##### Cloud Functions in Python instead Add `relia-sdk[otel,flask]` to `functions/requirements.txt`, then at the top of `main.py`: ```python import relia relia.start(project_id="", service_name="shop-functions") ``` Put `RELIA_KEY=` in `functions/.env`. The same serverless mode applies. #### Test with the emulator The emulator sends data too, so you can check before deploying. Put `RELIA_ENV=development` in `functions/.env.local` so test traffic stays apart from production. Restart a running emulator after adding Relia. The emulator loads a function's code during its first call, so that one call isn't recorded; deployed functions load first. When you're ready, deploy as usual with `firebase deploy --only functions`. #### Check it worked Open your web app once and call a function. On your project's **Setup** tab, **Visits to your web app** and **Requests from your server** change from *Not yet* to *Arriving*. Your function calls appear under **APIs**, and their Firestore calls under **Database**. #### If something's wrong - **The first call in the emulator is missing:** that's expected; call the function again. - **Function calls don't arrive after editing:** restart the emulator. Running workers keep the old code. - **Relia isn't loaded:** `require("./relia.tracing")` must come before `firebase-functions` and `firebase-admin`. - **Still "Not yet":** see [Relia shows no data](https://tryrelia.com/docs/no-data.md). #### Next - [Identify your users](https://tryrelia.com/docs/identify-users.md) - [Fix JavaScript errors in production](https://tryrelia.com/docs/javascript-errors.md) - [Teach Relia what matters](https://tryrelia.com/docs/teach-relia.md) ### Set up Relia on Cloudflare Workers, Vercel Edge and Deno > Wrap your edge handler in withRelia and add three settings, so each call to a Cloudflare Worker, Vercel or Netlify Edge function or Deno app shows up in Relia. Section: Set up your stack · Page: https://tryrelia.com/docs/edge-runtimes-setup · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/LhjBgPmhiF8 Edge runtimes don't run Node.js, so Relia has a small entry made for them: `relia-sdk/edge`. It uses only web-standard APIs and has no dependencies, so the same wrapper works on every platform. Supabase Edge Functions work the same way; see [Set up a Supabase app](https://tryrelia.com/docs/supabase-setup.md). > **Tip:** watch [How to monitor a Supabase app: database, Edge Functions and errors](https://youtu.be/lgFYplJANic) (2 min). #### Before you start - A Relia account ([Create your account](https://tryrelia.com/docs/create-account.md)). - Your project's id and key. In Relia, open your project, click **Setup Guide & SDK** and pick **Cloudflare Workers**: every step there already has your project's values. #### Steps (Cloudflare Workers) 1. **Install the package** in your worker's folder: ```bash npm install relia-sdk ``` 2. **Wrap your fetch handler** in `withRelia`. Your handler stays unchanged: ```ts import { withRelia } from "relia-sdk/edge" export default { fetch: withRelia(async (req, env, ctx) => { // your handler, unchanged }), } ``` Already have a handler object? Wrap its fetch: `fetch: withRelia(handler.fetch)`. 3. **Add the settings** to `wrangler.toml`: ```toml [vars] RELIA_PROJECT_ID = "" RELIA_SERVICE_NAME = "shop-worker" RELIA_KEY = "" ``` You can keep the key as a secret instead: ```bash wrangler secret put RELIA_KEY ``` 4. **For `wrangler dev`**, put the same names in `.dev.vars`, plus `RELIA_ENV=development` so test traffic stays apart from production. 5. **Start the worker and call it once.** Relia sends its data after the response, through `ctx.waitUntil`, so your users never wait for it. #### Deno and Deno Deploy No install. Import from npm directly and wrap the handler you pass to `Deno.serve`: ```ts import { withRelia } from "npm:relia-sdk/edge" Deno.serve(withRelia(async (req) => { // your handler, unchanged })) ``` Set `RELIA_PROJECT_ID`, `RELIA_KEY` and `RELIA_SERVICE_NAME` as environment variables. #### Vercel Edge and Netlify Edge Install `relia-sdk`, import `withRelia` from `relia-sdk/edge`, and wrap the exported handler the same way, for example: ```ts import { withRelia } from "relia-sdk/edge" export default withRelia(async (request) => { // your handler, unchanged }) ``` Put `RELIA_PROJECT_ID`, `RELIA_KEY` and `RELIA_SERVICE_NAME` in your host's environment variables. #### What Relia records - Each call as one request, with its route, status and time, and the error behind a failure. - Calls your handler makes with `fetch`, as outgoing calls. Supabase table calls become database calls, without their values. - Calls to AI models made with `fetch` inside the handler (OpenAI, Anthropic, Gemini, OpenRouter and others), as AI runs. See [Monitor AI calls in your app](https://tryrelia.com/docs/ai-calls-setup.md). #### Settings | Name | What it does | Default | |---|---|---| | `RELIA_PROJECT_ID` | Your project id. Without it, Relia stays off. | none | | `RELIA_KEY` | Your project key | none | | `RELIA_SERVICE_NAME` | The name your worker shows under in Relia | the first part of the request path | | `RELIA_ENV` | Environment label; use `development` locally | `production` | | `RELIA_FLUSH` | `before` sends before answering, for local servers that stop right after the response | after the response when the platform allows it, else before | | `RELIA_AI_CAPTURE` | `0` stops recording model calls | on | On Cloudflare Workers these are read from the `env` your handler receives; elsewhere from the environment. #### Check it worked Open your project in Relia and go to the **Setup** tab. **Requests from your server** changes from *Not yet* to *Arriving*. Your worker shows up under **APIs** by its service name. #### If something's wrong - **Nothing arrives:** check that `RELIA_PROJECT_ID` is set where the code runs. Without it, `withRelia` passes requests straight through and sends nothing. - **Nothing arrives from a local server:** add `RELIA_FLUSH=before` to your local settings. - **Still "Not yet":** see [Relia shows no data](https://tryrelia.com/docs/no-data.md). #### Next - [Set up a Supabase app](https://tryrelia.com/docs/supabase-setup.md) - [Monitor AI calls in your app](https://tryrelia.com/docs/ai-calls-setup.md) - [Teach Relia what matters](https://tryrelia.com/docs/teach-relia.md) ### Set up Relia in Go, Rust, Java, .NET and other languages > Connect an app in any language to Relia through OpenTelemetry, the open standard, with seven settings and your language's official OpenTelemetry setup. Section: Set up your stack · Page: https://tryrelia.com/docs/opentelemetry-setup · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/wg69A_5LhaU Node.js, Python and PHP have Relia's one-command setup. Every other language connects through **OpenTelemetry**, the open standard most languages and monitoring tools support. Your app uses the official OpenTelemetry libraries, so nothing in your code is tied to Relia. Incidents, the **APIs** page, database queries and fix plans work the same. #### Before you start - A Relia account ([Create your account](https://tryrelia.com/docs/create-account.md)). - Access to where your app is started: your host's settings, a Dockerfile or docker-compose file, a systemd unit, or a start script. #### Steps 1. **Open the settings card.** In Relia, open your project and click **Setup Guide & SDK**. Under **Or set it up yourself**, pick the tile **Go, Rust, Java…**. The card's settings are already filled in with your project's values. 2. **Copy the seven settings.** They look like this: ```bash OTEL_EXPORTER_OTLP_ENDPOINT=https://devotel.tryrelia.com OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf OTEL_EXPORTER_OTLP_HEADERS=x-relia-key= OTEL_RESOURCE_ATTRIBUTES=relia.project_id=,deployment.environment.name=production OTEL_SERVICE_NAME=api OTEL_METRICS_EXPORTER=none OTEL_LOGS_EXPORTER=none ``` The first line says where your data goes. The headers line holds your project key, and the next line your project id. 3. **Paste them where your app starts**, as environment variables. Go, Rust, Java and .NET don't read a `.env` file by themselves. 4. **On your laptop**, change `production` to `development` so test traffic stays apart from production. 5. **Add your language's OpenTelemetry setup** (below). Already using OpenTelemetry, for example with Datadog, Honeycomb or Grafana? Skip this step: the settings are all you change. > **Tip:** your AI assistant knows these steps for Go, Rust, Java and others. Watch [Set up production monitoring with one sentence to your AI assistant](https://youtu.be/_e0n2r1ZCq4) (2 min). 6. **Restart your app and use it once**: open a page or call an endpoint. Data arrives within a minute. #### Go Tested with `net/http`. Install: ```bash go get go.opentelemetry.io/otel go.opentelemetry.io/otel/sdk go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp github.com/XSAM/otelsql ``` Pick **Go** on the card and add the file `relia.go` it shows as it is, then run `go mod tidy`. In `main`: - call `setupRelia` first, and wrap your server with `otelhttp.NewHandler(mux, "server")`; - register routes with the card's `handle` helper, so each request carries its route template (`/orders/{id}`) and Relia shows one row per route, not one per order. With Gin, Echo or Chi, use their OpenTelemetry middleware (`otelgin`, `otelecho`, `otelchi`) instead; - open databases with `otelsql.Open` plus `otelsql.WithAttributes(attribute.String("db.system", "postgresql"))` (or `mysql`, `sqlite`) so they show on the **Database** page; - stop the server cleanly on a signal so the last requests are sent. `log.Fatal` skips that. #### Rust Tested with `axum`. Install: ```bash cargo add opentelemetry@0.33 opentelemetry_sdk@0.33 opentelemetry-http@0.33 tracing-opentelemetry@0.34 tracing tracing-subscriber cargo add opentelemetry-otlp@0.33 --no-default-features --features http-proto,reqwest-blocking-client,trace ``` The versions are pinned on purpose: the Rust OpenTelemetry libraries change between minor versions. Pick **Rust** on the card, add the `src/relia.rs` it shows as it is, and add `mod relia;` to `main.rs`. Call `relia::init()` first, add `.layer(axum::middleware::from_fn(relia::trace_requests))` after your routes, serve with `.with_graceful_shutdown(relia::shutdown_signal())`, then call `provider.shutdown()` so the last requests are sent. #### Java and Kotlin Spring Boot, Quarkus, Micronaut or plain Java, with no code change. Download the official agent and start your app with it: ```bash curl -L -O https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/download/v2.33.1/opentelemetry-javaagent.jar java -javaagent:opentelemetry-javaagent.jar -jar your-app.jar ``` Requests, database calls, outgoing calls and exceptions are recorded. Don't commit the jar (it's over 20 MB): download it in your Dockerfile or start script. #### .NET, Ruby and others Use your language's official OpenTelemetry setup with the OTLP exporter over HTTP, and the same settings: - **.NET**: the OpenTelemetry .NET automatic instrumentation. - **Ruby**: `opentelemetry-sdk`, `opentelemetry-exporter-otlp` and `opentelemetry-instrumentation-all`. #### Good to know - **One name per app:** give each app its own `OTEL_SERVICE_NAME`. Two apps under one name are mixed together. - **Route templates matter:** a request should carry `http.route` (like `/orders/{id}`). - **Who made a request:** set the span attributes `relia.user_id` and `relia.user_plan` (never an e-mail). See [Identify your users](https://tryrelia.com/docs/identify-users.md). - **Database values:** Relia's own SDKs remove values from queries. With OpenTelemetry that depends on your library; placeholders (`$1`, `?`) keep values out. #### Check it worked Open your project in Relia and go to the **Setup** tab. **Requests from your server** changes from *Not yet* to *Arriving*. Your requests and errors appear under **APIs**. #### If something's wrong - **Nothing arrives:** the variables must be set in the environment of the running process, not in a `.env` file the app never reads. - **The last requests before a stop are missing:** shut the tracer down when the app stops. - **One row per id instead of per route:** the request spans don't carry `http.route`. In Go, use the `handle` helper. - **Still "Not yet":** see [Relia shows no data](https://tryrelia.com/docs/no-data.md). #### Next - [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md), which knows these steps too - [Identify your users](https://tryrelia.com/docs/identify-users.md) - [Monitor API requests and errors](https://tryrelia.com/docs/apis.md) ### Identify your users > Tell Relia who your signed-in users are, so a problem names the people it hit ("3 customers on Pro") and you can look anyone up on the People page. Section: Set up your stack · Page: https://tryrelia.com/docs/identify-users · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/1mIOiHnI9nk Without this, when something breaks Relia can only say "3 visitors". Once it knows your users, it says "3 customers on Pro", and you can find any person by e-mail, name or id. It takes one or two lines in your code. #### Before you start - Relia set up in your app: see [Watch your web app](https://tryrelia.com/docs/web-app-setup.md) for the browser, or the setup page for your server ([Node.js](https://tryrelia.com/docs/node-express-setup.md), [Python](https://tryrelia.com/docs/python-setup.md), [Laravel or PHP](https://tryrelia.com/docs/laravel-php-setup.md)). - Your app has sign-in. No sign-in yet? Then there's nothing to add. #### Steps ##### In your web app 1. **Where sign-in finishes**, and when an already signed-in user loads the app, call `Relia.identify` with the user's id and details: ```ts import { Relia } from "relia-sdk" Relia.identify(user.id, { email: user.email, name: user.name, plan: user.plan }) ``` Calling it again with the same id updates the details, for example after an upgrade. 2. **On sign-out**, call: ```ts Relia.reset() ``` With Supabase or Firebase, set it up once next to the client: ```ts // Supabase supabase.auth.onAuthStateChange((_e, session) => session ? Relia.identify(session.user.id, { email: session.user.email }) : Relia.reset()) // Firebase onAuthStateChanged(auth, (u) => u ? Relia.identify(u.uid, { email: u.email ?? undefined, name: u.displayName ?? undefined }) : Relia.reset()) ``` ##### On your server Servers send only the user's id and plan, never an e-mail. - **Node.js (Express):** nothing to add if your sign-in sets `req.user.id`; Relia reads it by itself. To add the plan, or if your user lives elsewhere: ```js require("relia-sdk/node").setUser(req, { id: user.id, plan: user.plan }) ``` - **Python:** where your app knows the signed-in user (a dependency, middleware or view): ```python import relia relia.set_user(user.id, plan=user.plan) ``` - **Laravel:** the signed-in user's id is sent by itself. To add the plan, call this in a middleware: ```php \Relia\Relia::setUser(auth()->id(), auth()->user()?->plan); ``` In plain PHP, call `\Relia\Relia::setUser($userId, $plan)` once the user is known. - **Other languages (OpenTelemetry):** set the span attributes `relia.user_id` and `relia.user_plan` on the request span. > **Tip:** your AI assistant can add these lines for you. Ask it to *Set up Relia in this repository* and say yes to the users question. See [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md). #### What Relia keeps - The user's id, e-mail, name and plan. You may add up to 12 plain custom details of your own, about 1 KB in all. - Details that look like secrets or sensitive data (passwords, tokens, card numbers, phone numbers, addresses, health data and similar) are dropped in the browser and again on Relia's servers. Pass only id, e-mail, name and plan. - Who your users are is never sent to the AI and never appears in alerts (e-mail, Slack). Alerts and AI explanations only use counts and plan names. - Visits from the same browser before the person signed in are added to their history. #### The People page Once users arrive, **People** in the menu lists them. Search by e-mail, name or id and filter by plan. Open a person to see their plan over time, sessions, requests and errors. Lists show e-mails partly hidden; every time someone opens a person's profile, it is recorded in the audit log. Owners and admins can also: - **Export** everything Relia has on a person, as a file. - **Erase** their identity: their sessions stay, without the name, e-mail or details. #### Check it worked Sign in to your app once. On your project's **Setup** tab, **Who your users are** changes from *Optional* to *Arriving*, and the person appears on **People**. On Growth and Pro (and during the Pro trial), incidents now say who was hit, such as "3 customers on Pro". On Free, incidents show what was found and how big it is; who was affected is part of the explanation that paid plans unlock. > **Tip:** watch [How to read a production incident: what broke, who it hit, how to fix it](https://youtu.be/5PDrogf7ZJU) (2 min). #### If something's wrong - **Still "Optional" after signing in:** make sure `Relia.identify` runs after a successful sign-in, and also on page load for users who are already signed in. - **Someone else's sessions under one person:** call `Relia.reset()` on sign-out, so the next user on the same browser starts clean. - **No plan shown:** pass `plan` in `Relia.identify`, or with `setUser` / `set_user` on the server. #### Next - [Privacy in Relia](https://tryrelia.com/docs/privacy.md) - [Read an incident](https://tryrelia.com/docs/incidents.md) - [Visitors, sessions and page speed](https://tryrelia.com/docs/users-and-visitors.md) ### Monitor AI calls in your app > Once Relia is set up, every call your product makes to OpenAI, Anthropic, Gemini and other AI models, and every call to your MCP server's tools, shows up in Relia with no code change. Section: Set up your stack · Page: https://tryrelia.com/docs/ai-calls-setup · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/xcQ2aAHnrRM If your product uses AI, Relia watches it with nothing new to add: model calls become **AI runs**, and if your product has its own MCP server, each tool call is recorded too. You only need Relia set up on the server or edge code that makes the calls. #### Before you start - Relia set up where your AI calls happen: [Node.js](https://tryrelia.com/docs/node-express-setup.md), [Next.js](https://tryrelia.com/docs/nextjs-setup.md), [Python](https://tryrelia.com/docs/python-setup.md) or [edge runtimes](https://tryrelia.com/docs/edge-runtimes-setup.md). - The newest Relia SDK: version 0.8 or later on npm, 0.6 or later for Python. #### Steps 1. **Update the SDK** in your app's folder: ```bash npm i relia-sdk@latest ``` For Python: ```bash pip install -U relia-sdk ``` 2. **Restart your app and use its AI feature once.** That's all: your code stays the same. #### Which model calls are recorded Every call to OpenAI, Anthropic, Google Gemini, OpenRouter, Groq, Mistral, DeepSeek, Together, xAI, Perplexity, Fireworks or Cohere becomes an AI run, streamed answers included. Each run shows the model, tokens, estimated cost, how long it took and whether it failed. | Where | What is covered | |---|---| | Node.js | The official `openai` and `@anthropic-ai/sdk` packages, plain `fetch`, and the Vercel AI SDK (`streamText`, `generateText`) | | Python | The `openai` and `anthropic` packages, and anything using `httpx` or `requests` | | Edge (Supabase Edge Functions, Deno, Cloudflare Workers) | Calls made with `fetch` inside `withRelia` | A model call followed by a tool and another model call is one run, with the tool as a step in between. A request that is retried after a rate limit or server error counts as one run. A run made during a request joins that request, so if the request fails, the run is part of the same incident. Costs are estimates from public list prices. A model Relia doesn't know shows no cost rather than a guess. #### Your MCP server Does your product offer tools to AI assistants (Claude, Cursor, ChatGPT and others) through an MCP server built with the official MCP SDK, in Node.js or Python? Then every tool call is recorded: which tool, which assistant called it, how long it took and whether it failed. What the assistant asked and what the tool answered are never recorded. MCP tool calls cost no extra units; each AI run counts as 5 units of your monthly pool. #### Where to see it In Relia, open **AI in your product** in the menu: - **Runs** lists your model calls. - **Tool calls** shows the tools your AI uses, and below them, **Your MCP server** with each of its tools. Relia raises a finding when runs fail or get slow, when your AI's spend jumps well above its usual level, and when one of your MCP tools starts failing or slowing down. > **Tip:** watch [AI feature failing or costing too much? Monitor LLM calls and MCP tools](https://youtu.be/OCDIWdXLIQs) (2 min). #### Turn it off | Setting | What it does | |---|---| | `RELIA_AI_CAPTURE=0` | Stops recording model calls | | `RELIA_DISABLE_INSTRUMENTATIONS=mcp` | Stops recording MCP tool calls | Prompts and answers of model calls are kept with e-mail addresses masked. If you'd rather not keep them, turn model-call capture off. #### Check it worked Use your product's AI feature once. On your project's **Setup** tab, **AI agent runs** changes from *Optional* to *Arriving*, and the run appears under **AI in your product** → **Runs**. #### If something's wrong - **No runs:** check the SDK version (0.8 or later on npm, 0.6 or later for Python) and restart the app after updating. - **No runs from an edge function:** the model call must happen inside the handler wrapped with `withRelia`. - **Looking for Claude Code or Cursor themselves?** Those are your own AI assistants, connected to Relia from your profile. They don't appear here. See [Connect your AI assistant](https://tryrelia.com/docs/connect-ai-assistant.md). #### Next - [AI in your product](https://tryrelia.com/docs/ai-in-your-product.md) - [AI feature failing or costing too much?](https://tryrelia.com/docs/ai-feature-failing.md) - [Privacy in Relia](https://tryrelia.com/docs/privacy.md) ### Teach Relia what matters > Tell Relia in two short screens what your product does and which pages and APIs must never break, so problems there reach you first. Section: Make Relia yours · Page: https://tryrelia.com/docs/teach-relia · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/698N_bUto5Y Relia learns most things about your app from its data. Two things it can't guess: what your product is for, and which parts must never break. **Teach Relia** asks you exactly those two questions. It takes about two minutes. #### Before you start - A Relia project that is receiving data. Suggestions are better once Relia has seen some traffic. - You need to be an **owner** or **admin** of the project to save your answers. #### Steps 1. Open Teach Relia. On a new project, Home shows a card with **Teach Relia in 2 minutes**. You can also open it any time from the sidebar, under **Relia** → **Teach Relia**. 2. **Step 1 of 2: What does your product do?** Write one sentence, for example "An online shop for handmade furniture". Relia uses it to explain problems in your words. Click **Continue**. (If you leave it empty, the button says **Skip**.) 3. **Step 2 of 2: Anything that must never break?** This step is optional. - Under **Pages your users visit**, add the pages that matter, such as `/checkout`. Relia suggests your busiest pages; click one to add it. Ids in paths are fine: `/orders/123` and `/orders/456` count as the same page. - Under **Server endpoints your app calls**, pick a method (or **Any**), type a path such as `/api/search`, and click **Add**. Relia suggests APIs that change data. 4. Click **Save & finish**. You land back on Home. Not ready? **Finish later** takes you back to Home without saving. > **Note:** only these two answers change when you save. Everything Relia learned before, and every earlier answer you gave, stays as it was. #### What changes after you save - **Problems on these pages and APIs reach Needs you sooner.** From the next check, a problem on one of them goes to **Needs you** instead of **Worth watching**. - **Relia's checks visit them.** On Growth and Pro, Relia's synthetic checks open your critical pages (and the read-only APIs they call) every 15 minutes, the way a visitor would. Without critical pages, they use your busiest page. - **Promises (SLOs) follow them.** On Growth and Pro, the APIs you mark become the first candidates for the promises Relia proposes. - **Relia checks your answers later.** If a page you marked hasn't been visited for 14 days, Relia asks whether to remove it. > **Tip:** watch [Uptime monitoring and synthetic checks for your website](https://youtu.be/LDWbshEEOvk) (2 min). #### The rest Relia learns on its own Teach Relia used to ask more: who your users are, which paths to ignore, which forms show again on purpose. Now Relia learns those from the data and asks you only when it isn't sure, one question at a time, in **Relia asks** on Home. > **Tip:** watch [Relia asks: one question a day to learn your product](https://youtu.be/XspzZNUfUv8) (2 min). #### Check it worked - Open **Teach Relia** again: your sentence and your pages and APIs are filled in. - **What Relia learned** (sidebar, under **Relia**) shows what Relia now knows about your project. #### If something's wrong - **"Couldn't save. Try again."**: only owners and admins can save. Ask one of them, or check your role in **Team & plan**. - **No suggestions under the lists**: Relia hasn't seen enough traffic yet. Type the paths yourself, or come back after a day of real use. - **To change your answers**: open **Teach Relia** again and save. #### Next - [Read Home in 30 seconds](https://tryrelia.com/docs/home.md) - [Relia asks](https://tryrelia.com/docs/relia-asks.md) - [Choose how Relia reaches you](https://tryrelia.com/docs/notifications.md) - [Uptime and checks](https://tryrelia.com/docs/uptime-and-checks.md) ### Choose how Relia reaches you > Pick how much Relia tells you and where (email, Slack, ClickUp, Jira), and set up the daily summary. Section: Make Relia yours · Page: https://tryrelia.com/docs/notifications · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/hR4DCNd3SJA Relia sends one message per problem that needs you, in plain words, with what to do next. This page shows how to choose how many messages you get and where they arrive. #### Before you start - You need to be an **owner** or **admin** of the project to change notifications. Members and viewers see the settings but can't change them. - Email works on every plan. **Slack, ClickUp and Jira** come with **Growth** and **Pro**. On Free, Relia emails you the headline of each problem. #### Steps 1. Click **Settings** at the bottom of the sidebar (your project's page), then the **Notifications** tab. 2. Under **How much should Relia tell you?**, pick one: - **Only urgent**: one message per problem that needs a fix, and one when it's resolved. No summaries. - **Urgent + daily summary** (recommended, the default): the same, plus one summary a day. - **Everything**: also things worth watching, as they appear. Expect more messages. 3. Under **Where should Relia reach you?**, turn on the channels you want (below). 4. Click **Save** at the top of the tab. ##### Email With nothing set up, alerts go to the email address given when the project was created (usually yours). To use another address, turn on **Email Alerts** and type it. Incident alerts, the daily summary and uptime alerts go there. ##### Slack (Growth and Pro) 1. Click **Add to Slack** and approve Relia in Slack. 2. Back in Relia, under **Post alerts in**, choose the channel. For a private channel, invite the Relia app to it first. 3. Each alert in Slack has buttons: - **I'm on it**: tells your team you're handling it, and stops on-call escalation. - **Show how to fix**: posts the fix plan in the alert's thread. - **Expected**: marks the problem as on purpose. Later updates about the same problem are posted in the same thread. The buttons act as the Relia member linked to your Slack account (matched by email), with that member's permissions. Prefer a webhook? Open **Or paste an incoming webhook URL (links only, no buttons)**. Alerts arrive the same way, but without the buttons. ##### ClickUp (Growth and Pro) Turn ClickUp on, paste your **API Token**, **Workspace ID** and **Channel ID**, then click **Test Connection**. ##### Jira (Growth and Pro) Click **Connect with Atlassian Jira**, then pick a **Project** and an **Issue Type**. **Send Test Issue** checks it. Jira only gets a ticket for problems that need a fix, not for things worth watching. #### More options Click **More options** under the channels for: - Every switch on its own: **Also message me about things worth watching**, **Tell me when a problem I was messaged about is resolved**, and how many messages an hour (default 5, up to 60). Anything beyond the limit arrives bundled in one message. - **Daily summary** (Growth and Pro): **Every day** or **Every Monday**, at the hour you choose in your timezone. **Preview** shows today's summary; **Send one now** sends it. Nothing is sent when nothing happened at all. - **Source code in AI fix plans**: whether fix plans may include lines of your code. Off by default. - **Who is on call** and PagerDuty. See [On-call and escalation](https://tryrelia.com/docs/on-call.md). > **Tip:** watch [Set up on-call rotation and escalation (with PagerDuty)](https://youtu.be/Ar5NDRRDadk) (2 min). #### No repeats - Each problem is sent once. If it comes back after being resolved, you get one "came back" message. - Uptime monitors alert the moment a site goes down. Problems that start during that outage are listed in its "recovered" message instead of being sent twice. #### Check it worked Under **More options**, click **Send a test message** in **How Relia alerts you**. A sample alert arrives on every channel you turned on. The Slack card has its own **Send a test message** for the chosen channel. #### If something's wrong - **"Slack refused the message. Is the Relia app in that channel?"**: invite the Relia app to the channel, then test again. - **You see an upgrade card instead of Slack, ClickUp and Jira**: the project is on Free. Upgrade in **Team & plan**. - **"You have view-only access to this project"**: ask an owner or admin to change notifications. - **Too many messages**: switch to **Only urgent**, or lower the messages an hour under **More options**. #### Next - [On-call and escalation](https://tryrelia.com/docs/on-call.md) - [Invite your team](https://tryrelia.com/docs/team-and-roles.md) - [How to read an incident](https://tryrelia.com/docs/incidents.md) ### Invite your team > Invite teammates to a Relia project, pick their role, and know what each role can do. Section: Make Relia yours · Page: https://tryrelia.com/docs/team-and-roles · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/IarEexnMJfo A team in Relia belongs to a project. Each person on the project has one role that decides what they can do. #### Before you start - You need to be the **owner** or an **admin** of the project to invite people or change roles. - How many people fit depends on the project's plan: **Free** is 1 person (just you), **Growth** 5, **Pro** has no limit. Pending invites count toward the limit. #### Steps 1. Click **Settings** at the bottom of the sidebar, then the **Team & plan** tab. 2. Click **Invite Teammate**. 3. Type your teammate's email under **Teammate Email** and pick a **Project Role**: **Admin**, **Member** (the default) or **Viewer**. The box below the choice says what that role can do. 4. Click **Send Invitation**. The invite waits under **Pending Invitations** for 7 days. From there you can **Copy Link**, **Resend Email** or **Revoke Invite**. #### What your teammate does 1. They get an email: "Join *your project* on Relia". They click **Accept invitation**. 2. They sign in, or create an account with that email. 3. They click **Accept & Open Project** and land in the project. Back on **Team & plan**, they now appear in the members list. #### Roles | Role | What they can do | |---|---| | **Owner** | Everything, including billing and deleting the project. | | **Admin** | Everything except deleting the project and cancelling its subscription. Manages the team, notifications, integrations, and Relia's settings. | | **Member** | Uses everything: reads incidents, presses "I'm on it", gives Correct / Wrong feedback, asks Relia, edits postmortems. | | **Viewer** | Looks only. Can't acknowledge incidents, pin charts or edit postmortems. | Some answers are for owners and admins only, because they change what Relia believes or does: marking a problem **This is expected** or **Mute**, answering most **Relia asks** questions, undoing what Relia did, publishing a postmortem link, and approving runbook actions. > **Tip:** watch [Set up on-call rotation and escalation (with PagerDuty)](https://youtu.be/Ar5NDRRDadk) (2 min) once your team is in. #### Change or remove someone - **Change a role**: use the role menu next to the person on **Team & plan**. It saves right away. - **Remove someone**: use the remove option next to them and confirm **Remove Member**. - **Leave a project yourself**: choose **Leave Project**. Every change is recorded in the project's audit log (**Settings** → **Advanced** → **Audit log**, on Growth and Pro). #### Check it worked The person appears in the members list on **Team & plan** with the role you chose, and the project shows up in their project switcher. #### If something's wrong - **You can't invite more people**: the plan's team limit is reached (pending invites count). Revoke an old invite or upgrade the project in **Team & plan**. - **The invite expired**: it lasts 7 days. Click **Resend Email** or send a new one. - **The email didn't arrive**: ask them to check spam, or click **Copy Link** and send it to them yourself. - **No Invite Teammate button**: you are a member or viewer. Ask the owner or an admin. #### Next - [Choose how Relia reaches you](https://tryrelia.com/docs/notifications.md) - [On-call and escalation](https://tryrelia.com/docs/on-call.md) - [Plans and billing](https://tryrelia.com/docs/plans-and-billing.md) ### On-call and escalation > Set who is on call, hand over every day or week, escalate to the next person when nobody responds, and page through PagerDuty. Section: Make Relia yours · Page: https://tryrelia.com/docs/on-call · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/Ar5NDRRDadk When something needs a fix, on-call makes sure one person on your team is told directly, and that someone else is told if that person doesn't respond. #### Before you start - On-call comes with **Growth** and **Pro**. On Free, the card says to upgrade to Growth. - **Escalation** (telling the next person) needs **Pro**. On Growth, only the person on call is paged. - You need to be an **owner** or **admin** to change on-call. Everyone in the rotation must be a member of the project. See [Invite your team](https://tryrelia.com/docs/team-and-roles.md). #### Steps 1. Click **Settings** at the bottom of the sidebar, then the **Notifications** tab. 2. Click **More options**. Find the card **Who is on call**. 3. Under **Rotation (in order)**, add the people who handle problems, in the order they take turns. Use the arrows to move people up or down. 4. Optional: with Slack connected, type each person's **Slack member ID** (it starts with `U` or `W`). That person is then @mentioned in the alert in your Slack channel, so their phone buzzes. 5. Under **Hand over**, choose **every week** or **every day**, and the hour. Times are in the timezone shown next to the hour. By default the rotation hands over every week, on Monday, at 09:00. 6. Under **Tell the next person after**, choose how long to wait for someone to press "I'm on it" (5, 10, 15, 30 or 60 minutes; default 15), and how many people in total (1 to 3; default 3). This is the Pro escalation. 7. Optional, PagerDuty: paste an **Events API v2 integration key** and click **Connect**. PagerDuty then phones and texts the person on call. 8. Click **Save on-call**. > **Tip:** watch [Choose how Relia reaches you: email, Slack, ClickUp and Jira alerts](https://youtu.be/hR4DCNd3SJA) (2 min) to connect Slack first. #### Covers (holidays and sick days) Someone away? Add a cover: pick **Who covers…** and the dates **from** and **to**. During a cover, that person is on call first. Click **Save on-call** to keep it. Finished covers are removed when you save. #### What happens when something needs a fix 1. Relia sends its alert to your channels. The person on call is told directly by email, @mentioned in Slack if you added their member ID, and paged through PagerDuty if connected. 2. On the incident page, a box shows who is on call. When they click **I'm on it** (on the incident page or the Slack button), paging stops and PagerDuty marks the incident acknowledged. 3. On Pro, if nobody clicks **I'm on it** in time, Relia tells the next person in the rotation, up to the number you chose. 4. When the problem is gone, Relia resolves the PagerDuty incident. Only problems that **need a fix** page anyone. Things worth watching never do. A problem already covered by an uptime alert isn't paged twice. > **Note:** "I'm on it" is for owners, admins and members. Viewers can't acknowledge. #### Check it worked - The card shows **On call now:** with a name, when the shift ends, and who comes next. - Click **Send a test page**. The person on call gets a test by email (and a Slack mention if set). With PagerDuty, Relia opens and closes a test incident, and the card says "PagerDuty test incident opened and closed." #### If something's wrong - **"PagerDuty refused the key."**: use an **Events API v2** integration key from the PagerDuty service, not a REST API key. - **"Slack refused the message."**: check Slack is connected on the same tab and the Relia app is in the channel. - **Save on-call is greyed out**: a Slack member ID isn't in the right format. It looks like `U012AB3CD`. - **Nobody is paged**: make sure the card's switch is on and at least one person is in the rotation. #### Next - [Choose how Relia reaches you](https://tryrelia.com/docs/notifications.md) - [How to read an incident](https://tryrelia.com/docs/incidents.md) - [Plans and billing](https://tryrelia.com/docs/plans-and-billing.md) ### Plans and billing > Understand Free, Growth and Pro, the 14-day Pro trial, how usage is counted in units, and what happens at the limit. Section: Make Relia yours · Page: https://tryrelia.com/docs/plans-and-billing · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/2JpWprx6_tM Relia plans are **per project**. Every plan finds problems the same way; paid plans add the explanation, the fix and the team features. #### The free trial Every new account gets **14 days of Pro**, with no card needed. The sidebar shows **Pro trial** and how many days are left. When the trial ends, the project moves to Free unless you upgrade. Your data is kept. > **Tip:** watch [Create your Relia account (free 14-day Pro trial)](https://youtu.be/si2whGb2SSs) (2 min). #### The three plans | | Free | Growth | Pro | |---|---|---|---| | Price | $0 | $19 a month, or $15 a month billed yearly ($180) | $49 a month, or $39 a month billed yearly ($468) | | What it's for | Relia finds what breaks | Relia tells you why, and how to fix it | For a team that runs on-call | | Finds problems and emails you the headline | Yes | Yes | Yes | | Why it happened, who it hit, what to do | No | Yes | Yes | | Fix plans a month | No | 30 | 50 | | Ask Relia questions a month | 30 | 100 | 300 | | Postmortems a month | No | 10 | 30 | | Daily summary, Relia's checks, promises (SLOs) | No | Yes | Yes | | Alerts in Slack, ClickUp and Jira | No | Yes | Yes | | On-call and PagerDuty | No | Yes | Yes, with escalation | | Team members | 1 | 5 | Unlimited | | Units a month | 250,000 | 5 million | 20 million | | History kept | 7 days | 30 days | 90 days | The full list of limits is in [Plans and limits](https://tryrelia.com/docs/plans-and-limits.md). #### What "locked" looks like on Free On Free, Relia still finds every problem and emails you the headline. When you open an incident, you see the top (how bad, what broke, how many people) and a card: **See why it happened and how to fix it**, with "The explanation and the fix are part of the Growth plan." Other paid features show a similar upgrade card in place. #### See and change your plan 1. Click **Settings** at the bottom of the sidebar, then the **Team & plan** tab. 2. The **Current Plan** card shows this project's plan and what it allows. 3. Below it are the plans. Choose monthly or yearly and upgrade from there. Owners and admins can change the plan. Subscriptions started before the current prices keep their price. #### How usage is counted Each project has one pool of **units** per calendar month (UTC): | What | Units | |---|---| | A request to your server, or a log line | 1 | | A minute of a user session | 35 | | An AI agent run | 5 | | A page view (page-views-only mode) | 1 | The usage panel on **Team & plan** shows what you've used this month and when it resets. Relia emails you at 80% and at 100%. #### At the limit You are never cut off, and nothing already stored is deleted. Until the month resets (or you upgrade), Relia keeps about 1 in 10 normal requests and sessions, and always keeps errors and slow requests. On monthly Growth and Pro subscriptions, when the usage panel offers it, you can instead turn on **Allow paid extra use**: everything past the pool is kept for $2 per million units, billed with your plan, and never more than the monthly limit you set (at least $5). #### Give a month, get a month Share your link from **Give a month, get a month** in the sidebar (or your profile). When a founder who signed up with it starts paying, you both get a free month, up to 12 a year. The month waits in your balance until you choose which paid project gets it; that project's next charge moves one month later. #### Enterprise Need more volume, longer history or invoices? Write to relia@alaknandainfoplus.com. #### Next - [Plans and limits](https://tryrelia.com/docs/plans-and-limits.md) - [Invite your team](https://tryrelia.com/docs/team-and-roles.md) - [On-call and escalation](https://tryrelia.com/docs/on-call.md) - [Control what Relia collects](https://tryrelia.com/docs/sdk-settings.md) ### Read Home in 30 seconds > Know from one screen whether your app is OK, what needs you, what Relia is watching and what it did on its own. Section: Use Relia every day · Page: https://tryrelia.com/docs/home · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/BAdQtGBxezQ Home is the first page you see in Relia. It answers one question, "is my app OK?", and then lists what needs you, most important first. Read it top to bottom. #### The top line - A greeting and today's date. - A dot with **Watching · last check** and how long ago. Relia checks your product every few minutes, whether or not you have the app open. - The **verdict**, in one line: - **All good.** Nothing needs you. If Relia is keeping an eye on small things, it says how many. - **One thing needs you.** or **3 things need you.** when something is broken for real people. On the right: **Health** opens Relia's own health page (is Relia working, and how accurate it has been), and owners and admins can click **Check now** to run a check immediately. #### For you Each row is one problem (an **incident**). A red edge means it **needs you**. Each row shows: - The headline, such as "Placing an order fails after the 10:00 deploy". - **Do this:** the next step. - How severe it is, how many people it hit, and which parts of your product it touched. Click a row to open the full incident. See [How to read an incident](https://tryrelia.com/docs/incidents.md). Also in **For you**: - When a part of your product (users, APIs, servers, AI) has nothing that needs a fix, its biggest "worth watching" problem is shown here, so no part is drowned out. - **Relia asks**: one question when Relia isn't sure about your app. See [Relia asks](https://tryrelia.com/docs/relia-asks.md). When nothing needs you, it says: "Nothing needs you right now. Relia will message you the moment something does." On a new project, owners and admins also see a card with **Teach Relia in 2 minutes** below this list. See [Teach Relia what matters](https://tryrelia.com/docs/teach-relia.md). #### Worth watching Problems with an amber edge. They aren't urgent, so the hint says **Nothing to do yet.** Relia keeps an eye on them for you. #### Relia did What Relia changed on its own, such as a check it added or a pattern it learned to treat as normal, each with the reason. Owners and admins can click **Undo** on any of them. Nothing is deleted; the change is switched off. > **Tip:** watch [What Relia did on its own, and how to undo it](https://youtu.be/PZuW0boeoAU) (2 min). #### Your product right now On the right, one row per part of your product (users, page speed, APIs, database, servers, uptime and checks, promises, status page, AI in your product). Each is marked: | Word | Colour | Means | |---|---|---| | **Normal** | Green | Nothing wrong. | | **Watch** | Amber | Worth a look. | | **Needs you** | Red | Something there needs a fix. | | **No data yet** | Grey | That part isn't sending data yet. | Each row has a one-line summary and lists the incidents that started in that part. The same colours appear as dots beside each part in the sidebar, and the red badge on **Home** in the sidebar counts what needs you. Below that: your starred dashboards, **Pinned charts** from Ask Relia, and a folded list of minor things Relia noticed. > **Tip:** watch [A tour of Relia: every part of your product in one place](https://youtu.be/xdjhnok11dY) (2 min). #### In short Red needs you. Amber is worth a look. Green is normal. Relia messages you when something turns red, so you don't need to keep Home open. #### Next - [How to read an incident](https://tryrelia.com/docs/incidents.md) - [Relia asks](https://tryrelia.com/docs/relia-asks.md) - [Ask Relia](https://tryrelia.com/docs/ask-relia.md) - [Choose how Relia reaches you](https://tryrelia.com/docs/notifications.md) ### How to read an incident > Read an incident from top to bottom: how bad it is, what happened, who it hit, why Relia thinks so, and the one thing to do next. Section: Use Relia every day · Page: https://tryrelia.com/docs/incidents · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/5PDrogf7ZJU When something goes wrong, Relia groups everything that belongs together (the failing API, the error behind it, the people who hit it, the deploy just before) into one **incident**. Open one from **Home** by clicking its row. #### How Relia sorts problems | Bucket | Means | Alerts you? | |---|---|---| | **Needs you** | Broken for real people, or about to be. | Yes | | **Worth watching** | Worth a look, not urgent. | Only if you chose **Everything** in [notifications](https://tryrelia.com/docs/notifications.md) | | **Low priority** | Context. | No | Relia decides this with fixed rules, not guesses: for example, most problems must be seen at least 3 times before they need you (a site that is down needs you at once), and a problem on a page or API you marked as must-never-break is raised sooner ([Teach Relia](https://tryrelia.com/docs/teach-relia.md)). #### The top - The bucket (**Needs you**, **Worth watching** or **Low priority**), the severity (**critical**, **high**, **medium** or **low**), the kind (**Bug**, **Performance**, **Infrastructure**, **User experience**…) and the status (open, came back, resolved). - The headline, such as "Placing an order fails after the 10:00 deploy". - How many people it hit, sessions and failed requests, when it started and when it was last seen. - If you [identify your users](https://tryrelia.com/docs/identify-users.md), how many signed-in customers it hit and their plans, with links to each person. - **Mostly:** when the problem is concentrated in one browser, device, country or page. - **Related problems and history**: similar problems on the same page or API, and whether this happened before. #### The story (Growth and Pro) - **What happened**: the story in plain words. Every number comes from Relia's evidence. - **How to fix it**: click **Show how to fix** for a fix plan. See [Fix it and confirm the fix worked](https://tryrelia.com/docs/fix-and-verify.md). - **Why Relia thinks so**: Relia's confidence, and the links it found between parts of your stack. - **high**: linked end to end with a code or infrastructure cause. - **medium**: linked, but the exact cause isn't proven. - **low**: a pattern, not yet tied to a cause. - **How it unfolded**: the steps in order. The first one is the likely origin, for example an error in the orders code right after a deploy. - **Across your stack** (closed at first, click **Show**): one lane per layer (Users, Server, Database, Dependencies, Host, Changes and more), each finding with links. A session link opens the visitor's session at the moment it broke; a request link opens that request with its database queries and the error. #### The side column - **Do this next**: the one thing to do. - **I'm on it**: tells your team you're handling it and stops on-call paging. Viewers can't press it. - **Fixed it?** → **I fixed it**: once your fix is out, Relia watches real traffic to confirm it. - **Recent changes**: deploys, restarts and new servers around the time it started. - **Is this right?**: tell Relia when it's wrong. See [Teach Relia when an alert is wrong](https://tryrelia.com/docs/feedback.md). Some incidents also carry a question when Relia can't tell whether a behaviour is on purpose, with the answers **Yes, that's expected** and **No, that's a bug**. > **Tip:** watch [Teach Relia when an alert is wrong (fewer false alarms)](https://youtu.be/QMYMDqJ98Y4) (2 min). #### On the Free plan You still see the top: how bad it is, the headline, how many people it hit and when it started. The rest is replaced by **See why it happened and how to fix it**: "The explanation and the fix are part of the Growth plan." Relia still names how many findings it linked and across which layers. #### When an incident ends An incident is resolved when the problem stops (after a quiet period), or when Relia confirms your fix worked. If it comes back, it reopens as "came back" and you get one message about it. #### Next - [Fix it and confirm the fix worked](https://tryrelia.com/docs/fix-and-verify.md) - [Teach Relia when an alert is wrong](https://tryrelia.com/docs/feedback.md) - [Write a postmortem](https://tryrelia.com/docs/postmortems.md) - [A deploy broke checkout](https://tryrelia.com/docs/deploy-broke-checkout.md) ### Fix it and confirm the fix worked > Get a fix plan for an incident, hand it to your AI assistant, ship the fix, and let Relia confirm on real traffic that it worked. Section: Use Relia every day · Page: https://tryrelia.com/docs/fix-and-verify · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/gtORFurIkow When an incident needs you, Relia can write a fix plan from its evidence. After you ship the fix, Relia watches real traffic and tells you **"Your fix worked"** or **"Still happening after your fix"**. #### Before you start - Fix plans come with **Growth** (30 a month) and **Pro** (50 a month). On Free, the incident page shows an upgrade card instead. - Fix verification works on every plan. - An open incident. See [How to read an incident](https://tryrelia.com/docs/incidents.md). #### Steps 1. Open the incident from **Home**. 2. Under **How to fix it**, click **Show how to fix**. Relia works out the fix from the evidence: failing requests, stack traces, database queries and server metrics. 3. Read the plan: - A one-line summary and the **Root cause**. - Up to 5 numbered steps. Each is labelled **Code**, **Database**, **Config**, **Server** or **Check**, says where (a file and line, a table, a setting) and what to change. **Copy** copies one step's change. - **Careful:** risks to keep in mind, and **How you'll know:** how to check it worked. 4. Make the change: - Click **Copy for your AI assistant** and paste the brief into Claude Code, Cursor or any assistant. It edits the code in your editor, with your approval. - Or let your assistant read the plan and the evidence from Relia itself. See [Fix bugs from your editor](https://tryrelia.com/docs/from-your-editor.md). 5. Deploy the fix as you normally do. 6. Click **I applied this fix** at the bottom of the plan, or **I fixed it** in the side column. If your app reports its version (Relia's SDKs do this from your commit or package version), Relia notices the deploy on its own and you don't need to click anything. > **Important:** Relia never changes your code and has no access to your repository. Code lines are only sent to the AI writing the plan if you turn on **Source code in AI fix plans** (**Settings** → **Notifications** → **More options**). Not happy with the plan? Click **Regenerate**. > **Tip:** watch [Fix production bugs from your editor with Claude Code and Cursor](https://youtu.be/67fIYRYKZWk) (2 min) to hand the plan to your assistant. #### How Relia confirms the fix After the fix lands, the side column shows **Checking your fix**. Relia then decides: | Result | When | |---|---| | **Fix confirmed** | At least 20 requests reached the affected APIs over at least 15 minutes, and the problem never came back. For problems with no API (servers, pages), 30 quiet minutes. The incident is resolved and you get "Your fix worked". | | **Still happening** | The problem showed up again after the fix. You get "Still happening after your fix" and can try again with **I fixed it again**. | | **Not confirmed yet** | After 24 hours there still wasn't enough traffic to tell. | You get each of these messages once, on the channels you chose in [notifications](https://tryrelia.com/docs/notifications.md). #### Rollbacks If you connected a deploy platform (**Settings** → **Advanced** → **Integrations**) and a deploy caused the problem, Relia may propose a rollback on the incident page. Nothing runs until an owner or admin approves it; it then runs through your connected platform and Relia checks the result the same way. > **Tip:** watch [A deploy broke checkout: find the cause and verify the fix](https://youtu.be/rRvqe6r_WRU) (2 min). #### Check the fix worked - The incident's side column shows **Fix confirmed**, and the incident moves out of **For you** on Home. - You receive "Your fix worked". #### If something's wrong - **"This month's fix plans on the … plan (…) are used up"**: the plan's monthly allowance is spent. It renews on the 1st (UTC), or upgrade in **Team & plan**. - **"Couldn't build a fix right now"**: try again in a minute. - **The steps are vague about where to change code**: the plan only uses what Relia recorded. Upload [source maps](https://tryrelia.com/docs/source-maps.md) for browser errors, and make sure your server sends stack traces, so steps can name the file and line. - **Stuck on Not confirmed yet**: the affected page or API gets little traffic. Check it yourself, then keep an eye on the incident. #### Next - [Fix bugs from your editor](https://tryrelia.com/docs/from-your-editor.md) - [Write a postmortem](https://tryrelia.com/docs/postmortems.md) - [A deploy broke checkout](https://tryrelia.com/docs/deploy-broke-checkout.md) - [Did my deploy break anything?](https://tryrelia.com/docs/did-my-deploy-break.md) ### Teach Relia when an alert is wrong > Use Correct, Wrong, This is expected and Mute on an incident so Relia learns what is normal for your product and alerts you less. Section: Use Relia every day · Page: https://tryrelia.com/docs/feedback · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/QMYMDqJ98Y4 Relia learns what is normal for your product from its data, but you know things it can't see. Every incident has a panel, **Is this right?**, where you tell Relia when it got something right or wrong. Your answer only affects this project. #### Where to find it Open an incident from **Home**. In the side column, find **Is this right?**. It has four buttons. #### The four answers | Button | Means | What Relia does | |---|---|---| | **Correct** | Relia got it right. | Remembers it as a good example, so it explains things the way you like. | | **Wrong** | Relia got it wrong. | Learns from it for this project. A kind of problem you keep marking wrong is lowered to **Watch**. | | **This is expected** | This is normal for you. | Treats the problem as normal for this project and stays quiet about it. | | **Mute** | Stop raising this. | Won't raise this problem again. | After you answer, the panel shows what Relia will do, who answered and when. > **Note:** an answer covers the problem in the headline (the root of the incident), not every finding linked to it. Marking one slow API as expected does not hide other slow APIs. #### When a kind gets lowered Relia lowers a kind of problem to **Watch** for your project once you've answered on it at least 3 times and most of those answers (60% or more) were **Wrong** or **Mute**. The lowered incidents say why on their card. You can see what was lowered under **What Relia learned** (sidebar, under **Relia**) → **Learned from your feedback**. #### Who can answer - **Correct** and **Wrong**: anyone on the project. - **This is expected** and **Mute**: owners and admins only, because they change what Relia raises for the whole team. Other people only see Correct and Wrong. #### Change your mind Click **Change answer** and pick again. The new answer undoes what the old one did. For example, answering **Correct** or **Wrong** on an incident you had muted makes it a real problem again. #### "That's a bug" Some incidents carry a question when Relia can't tell whether a behaviour is on purpose. Answering **No, that's a bug** tells Relia to always treat this problem as one that **needs you**. Answering **Yes, that's expected** works like **This is expected**. Both are for owners and admins. #### From Slack If you connected the Slack app, every alert has an **Expected** button. It works like **This is expected**, as the Relia member linked to your Slack account. See [Choose how Relia reaches you](https://tryrelia.com/docs/notifications.md). > **Tip:** watch [Relia asks: one question a day to learn your product](https://youtu.be/XspzZNUfUv8) (2 min) for the other way Relia learns from you. #### From your AI assistant Your assistant can give the same answers with the `relia_set_verdict` tool. It asks you first, and your role still applies. See [Fix bugs from your editor](https://tryrelia.com/docs/from-your-editor.md). #### Next - [How to read an incident](https://tryrelia.com/docs/incidents.md) - [Relia asks](https://tryrelia.com/docs/relia-asks.md) - [What Relia did, and how to undo it](https://tryrelia.com/docs/what-relia-did.md) ### Relia asks > Answer the one question Relia asks when it isn't sure about your app, and know what each answer changes. Section: Use Relia every day · Page: https://tryrelia.com/docs/relia-asks · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/XspzZNUfUv8 Relia learns most of what is normal for your app on its own. When it isn't sure, it asks you, one question at a time, with the evidence it used. Answers apply at once. #### Where questions appear On **Home**, under **For you**, in a card marked **Relia asks**. The card shows the question, a line starting with **Evidence:** (the numbers behind it), and the answer buttons. The question on screen also appears in your daily summary. #### How often - At most **one new question a day** and **five a week**, so it never floods you. - A question stays on screen until it's answered. - Only urgent questions skip the wait, such as whether to post an outage on your public status page while customers are affected. #### Kinds of questions | Relia asks | Answers | What a yes does | |---|---|---| | Should one of your busiest pages, or an API that changes data, never break? | **Yes, protect it** · **No** · **Not sure** | Problems there reach **Needs you** sooner, like pages you add in [Teach Relia](https://tryrelia.com/docs/teach-relia.md). | | A pattern looks on purpose (an API called steadily all day, a nightly job, an API that refuses by design). Treat it as normal? | **Yes** (for example **Yes, it's polling**) · **No** · **Not sure** | Relia stops raising that pattern on that path. Errors (5xx) are never hidden this way. | | Should Relia add something, such as an uptime monitor for your API's public address? | **Yes, add it** · **No** · **Not sure** | Relia creates it and lists it under **Relia did** on Home, with the reason "you said yes". | | A page you said must never break hasn't been visited in weeks. Remove it? | **Remove it** · **Keep it** · **Not sure** | Relia stops treating it as critical. | | Many people struggle with the same button or row. Change it? | **Yes, I'll change it** · **It's fine as it is** · **Not sure** | Relia hides the suggestion, and shows it again if people still struggle there. | Funnels can come up too: whether to keep watching a journey Relia found and named, or to follow a goal it saw (for example sign-ups) as a funnel. > **Tip:** watch [What Relia did on its own, and how to undo it](https://youtu.be/PZuW0boeoAU) (2 min). #### Not sure and Keep it - **Not sure**: Relia keeps watching and asks again in 7 days, only if the evidence changed. - **Keep it**: Relia asks again in 30 days. Neither is final, so the question can come back. Every other answer is final. #### Who can answer Only **owners** and **admins** can give answers that change what Relia believes or does. Everyone else can still pick **Not sure**; the other buttons are greyed out for them. #### After you answer A short note confirms your answer (for example "Saved. Relia uses this from the next check."). The next question, if any, comes on a later day. If the answer added something, it appears under **Relia did** on Home, where owners and admins can **Undo** it. #### Choose what Relia may do without asking In **Settings** → **Advanced** → **Autonomy**, choose per kind of change whether Relia does it on its own, asks first, or never does it. For example, new uptime monitors are "ask first" by default. #### Teach Relia from Ask Relia When you tell Ask Relia something about your app (for example "the /health API is called by our load balancer every minute"), it may show **Save this?** under the answer. Nothing is saved until you click yes. See [Ask Relia](https://tryrelia.com/docs/ask-relia.md). #### Next - [Teach Relia what matters](https://tryrelia.com/docs/teach-relia.md) - [Teach Relia when an alert is wrong](https://tryrelia.com/docs/feedback.md) - [What Relia did, and how to undo it](https://tryrelia.com/docs/what-relia-did.md) ### Ask Relia > Ask questions about your live app in plain words, check the evidence behind every answer, and turn numbers into charts and dashboards. Section: Use Relia every day · Page: https://tryrelia.com/docs/ask-relia · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/z3LCOFL7T_U **Ask Relia** answers questions about your product from its real data: "Is checkout working?", "Which API is slowest today?", "Why is /orders failing?", "Show response times this week". #### Before you start - A Relia project that is receiving data. - Each plan includes a number of Ask Relia answers per project each month: **30** on Free, **100** on Growth, **300** on Pro. They renew on the 1st (UTC). #### Steps 1. Click **Ask Relia** in the sidebar. The page asks **What do you want to know?** 2. Type your question in the box, or click one of the suggested questions. Suggestions come from your project's state, such as a problem that needs you right now. 3. Read the answer. It starts with a one-line verdict ("No, placing an order fails."), then a few short bullets or numbered steps, with the key thing in **bold**. 4. Click the links in the answer to check the evidence. "Incident 1" opens the incident; "failing request 1" opens that request; an area link opens that part of your product. 5. Ask a follow-up in the same conversation, or click **New question** to start over. Earlier conversations are under **History** (top right). They are private to you. #### How answers stay honest - Answers use **only this project's data**. If the data doesn't hold the answer, Relia says so instead of guessing. - Every claim links to its evidence. Links Relia can't back up are removed. - Ask Relia only reads. It never changes your app or your settings. #### Charts Ask for a chart, for example "Show response times this week" or "Which pages are slowest, as a bar chart". The chart appears in the answer with a one-line summary of what it shows. Click **Pin** to keep it. It turns to **Pinned**, and the chart waits for you on **Home** under **Pinned charts**, with fresh data each time. Viewers can't pin charts. Relia can chart requests, errors and response times, servers, database queries, dependencies, visitors and sessions, page speed (LCP, INP, CLS), uptime, error budgets, logs, funnels and AI runs. #### Dashboards Ask "Make me a dashboard for checkout". Relia builds a dashboard of a few charts and gives you a link. You can also ask it to change an existing dashboard; nothing changes until you click **Save** on the dashboard. The number of dashboards per project depends on the plan (2 on Free, 10 on Growth, 30 on Pro). > **Tip:** watch [Build monitoring dashboards in minutes (templates, filters, TV mode)](https://youtu.be/0m3zt2P2XM0) (2 min). #### Teach Relia while you ask - Tell Relia something about your app and it may show **Save this?** under the answer. Nothing is saved until you click yes. See [Relia asks](https://tryrelia.com/docs/relia-asks.md). - Ask about a journey ("how many people finish checkout?") and on Growth and Pro it may offer a **Save this funnel** card. #### Ask from your editor The same answers are available in Claude Code, Cursor and other AI assistants, through Relia's `relia_ask` tool. They count against the same allowance. See [Fix bugs from your editor](https://tryrelia.com/docs/from-your-editor.md). #### If something's wrong - **"This month's Ask Relia answers on the … plan (…) are used up"**: the monthly allowance is spent. It renews on the 1st, or upgrade in **Team & plan**. - **"Couldn't get an answer"**: try again in a minute. - **A how-to question about Relia itself** (setup, billing, Slack): use **Help & support** in the sidebar instead. Ask Relia answers questions about your product's data. #### Next - [Read Home in 30 seconds](https://tryrelia.com/docs/home.md) - [Dashboards](https://tryrelia.com/docs/dashboards.md) - [Fix bugs from your editor](https://tryrelia.com/docs/from-your-editor.md) ### Fix bugs from your editor > Use Relia every day from Claude Code, Cursor or any AI assistant with four questions, from "what needs my attention?" to "did my deploy break anything?". Section: Use Relia every day · Page: https://tryrelia.com/docs/from-your-editor · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/67fIYRYKZWk Once your AI assistant is connected to Relia, you can do your daily Relia work without leaving your editor. Your assistant reads Relia's evidence, and the code changes happen in your editor, with your approval. #### Before you start - Your AI assistant is connected to Relia. If not, run this once in a terminal and restart your tools: ```bash npx -y relia-sdk@latest mcp install ``` See [Connect your AI assistant](https://tryrelia.com/docs/connect-ai-assistant.md). - Open the repository of the app Relia watches. In a repository set up with Relia, your assistant finds the project id in `.env.local` (`RELIA_PROJECT_ID`) or in `src/relia.ts` / `relia.tracing.js`. With several projects, you can also name the project in your question. - On **Free**, your assistant gets Relia's status and each problem's headline. Explanations and fix plans need **Growth** or **Pro**. > **Tip:** watch [Connect Claude Code, Cursor and Codex to Relia (MCP setup)](https://youtu.be/fpGlCkJzzKA) (2 min). #### Steps 1. **Ask what needs you.** ```text Use Relia: what needs my attention? ``` Your assistant calls Relia's status tool and answers in plain words, for example "GET /api/search has been failing since just after 3 p.m., 46 users affected". 2. **Ask for the fix.** ```text Show me how to fix it. ``` Your assistant reads the incident and Relia's fix plan: the root cause, the file and the line. It shows you the change before writing anything. Say yes, and it edits the file. Then deploy as you normally do. Getting the fix plan the first time uses one of your plan's monthly fix plans. 3. **Mark it fixed.** ```text Mark it fixed in Relia. ``` Relia changes nothing without your yes, so your assistant asks you first. Say yes, and Relia starts watching real traffic. Once enough requests pass without the problem, Relia confirms the fix and sends "Your fix worked". See [Fix it and confirm the fix worked](https://tryrelia.com/docs/fix-and-verify.md). 4. **Check your deploy.** ```text Did my last deploy break anything? ``` Your assistant reads recent deploys and changes, then what started or got worse after the latest one, and tells you whether the deploy is fine. #### Ready-made prompts Claude Code and other tools list Relia's prompts. In Claude Code, type `/mcp__relia__` to see them: | Prompt | What it does | |---|---| | `fix-top` | **Fix the most important problem**: finds it, reads its evidence and fix plan, fixes it in your code, then offers to have Relia verify the fix. | | `deploy-check` | **Did my last deploy break anything?** Compares before and after the latest deploy. | | `review-pr` | **Review this change against production**: checks your current diff against how those routes, queries and pages behave live. | | `status` | **What needs my attention?** | | `check` | **Is Relia receiving everything?** | | `setup` | **Set up Relia** in this repository. | #### What your assistant can and can't do - **Reads freely**: status, incidents, fix plans, Ask Relia answers, dashboards, funnels, requests (`relia_trace`), logs, sessions, database queries, page speed, uptime and recent changes. - **Asks you first**, every time: marking a fix (`relia_mark_fixed`), giving a verdict on an incident (`relia_set_verdict`), "I'm on it" (`relia_ack`), recording a deploy (`relia_report_change`) and creating a project. Relia refuses these without your confirmation, and each one is in the project's audit log. - **Your role applies**: a viewer can't acknowledge, and only owners and admins can mark something expected. - **Can't** change Relia's settings, delete data, or see passwords. Relia itself never changes your code. The full list is in [MCP tools](https://tryrelia.com/docs/mcp-tools.md). #### If something's wrong - **Your assistant doesn't know Relia**: restart the tool after `mcp install`. In Claude Code, type `/mcp`, pick **relia** and choose **Authenticate**. - **It picks the wrong project**: name the project in your question, for example "Use Relia project Shop". - **"Upgrade" instead of a fix plan**: the project is on Free. See [Plans and billing](https://tryrelia.com/docs/plans-and-billing.md). #### Next - [Connect your AI assistant](https://tryrelia.com/docs/connect-ai-assistant.md) - [MCP tools](https://tryrelia.com/docs/mcp-tools.md) - [Did my deploy break anything?](https://tryrelia.com/docs/did-my-deploy-break.md) - [Your AI assistant can't reach Relia?](https://tryrelia.com/docs/mcp-connection.md) ### Write a postmortem > Write an incident postmortem in one click from what Relia recorded, edit it in your words, copy it as Markdown, and share a public link. Section: Use Relia every day · Page: https://tryrelia.com/docs/postmortems · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/yvFuLiaGRz4 A postmortem explains what went wrong, what it cost and what you'll change. Relia writes one from what it recorded during the incident, with real numbers and a timeline, so you only review and edit. #### Before you start - Writing a postmortem comes with **Growth** (10 a month) and **Pro** (30 a month). A postmortem written earlier can always be read. - Anyone on the project can write one. Owners, admins and members can edit it; viewers can read and copy it. - Best after the incident is resolved, ideally with a confirmed fix. See [Fix it and confirm the fix worked](https://tryrelia.com/docs/fix-and-verify.md). > **Tip:** watch [From alert to verified fix: fix plan, apply, and "Your fix worked"](https://youtu.be/gtORFurIkow) (2 min). #### Steps 1. Open the incident from **Home** (or from the resolved incidents). 2. Find the postmortem bar under **How to fix it**. Click **Write the postmortem**. While the incident is still open, the button says **Draft the postmortem**: it writes what is known so far, and you update it once the problem is resolved. 3. When it's written, click **Open**. 4. Review the sections: - **Title** and **Summary**. - **Impact**, with the measured numbers (people, failed requests, how long it lasted). - **Timeline**: from the first error, through alerts, "I'm on it", deploys and the fix attempt, to the confirmed fix and resolution. - **Root cause**, in numbered steps, each with the evidence behind it. - **What was done**, **What we change** (a checklist) and **Lessons**. - **Evidence Relia wrote this from**: every fact it used, folded at the bottom. 5. To use your own words, click **Edit** on a section, change the text and click **Save**. The section is marked "(your words)". In list sections, put one item per line. #### Rewrite, copy, publish - **Use Relia's text** on an edited section puts Relia's words back. - **Rewrite** writes the postmortem again. Your edited sections stay as you wrote them. If the incident changed since it was written, the page says "The incident changed since this was written." and the button says **Update to the latest facts**. - **Copy as Markdown** copies the whole postmortem with its headings, ready to paste into your docs or a ticket. - **Publish a link** (owners and admins) makes a public page anyone with the link can read. **Unpublish** takes it down again. #### What the public link hides The public page is a masked copy. Internal details are removed before anyone outside sees it: - Server names become "a server". - Network addresses, trace ids, email addresses and raw routes are removed. - Your team members' names become "an engineer", and the name of whoever acknowledged the incident is dropped. #### How Relia keeps it factual Every number and time in the text must come from what Relia recorded. If Relia's prose doesn't pass that check, you get a facts-and-timeline-only version, and the page says "Facts and timeline only: Relia's prose did not pass its own evidence check." You can still edit every section yourself. #### If something's wrong - **"This month's postmortems on your plan are used up."**: the monthly allowance is spent. It renews on the 1st, or upgrade in **Team & plan**. - **No postmortem bar on the incident**: the project is on Free, where the incident's explanation is locked. Upgrade to Growth. - **Publish a link is missing**: only owners and admins can publish. #### Next - [How to read an incident](https://tryrelia.com/docs/incidents.md) - [Fix it and confirm the fix worked](https://tryrelia.com/docs/fix-and-verify.md) - [Public status page](https://tryrelia.com/docs/status-page.md) - [A deploy broke checkout](https://tryrelia.com/docs/deploy-broke-checkout.md) ### A deploy broke something important > When a release breaks a key flow like checkout, find the failing API, the error and the deploy behind it, roll back or fix, and let Relia confirm the fix on real traffic. Section: Find and fix real problems · Page: https://tryrelia.com/docs/deploy-broke-checkout · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/rRvqe6r_WRU A new version goes out and minutes later something important stops working: orders fail, sign-ups fail, payments fail. This page shows how Relia ties the failure to the release, and how to confirm your fix. The example is Relia's demo shop (you can open it at `https://app.tryrelia.com/demo`): at 10:00 the shop deploys api 1.11.0, and placing an order starts failing. #### What you'll see - **Home** says something needs you, with a headline such as *POST /api/orders is failing* and how many users or requests it hit. The part where it started (usually **APIs**) shows **Needs you**. - You get an alert on the channels you chose (e-mail on every plan; Slack, ClickUp and Jira on Growth and Pro). See [Choose how Relia reaches you](https://tryrelia.com/docs/notifications.md). - Relia raises it as **Needs you** only once it has seen the failure at least 3 times, so one stray error doesn't page you. Relia notices a failing API when its error rate is well above its own normal for that route. A route that normally fails 0.4% of the time and now fails 35% stands out at once. > **Note:** On the Free plan an incident shows its headline and numbers. The evidence, the cause chain and **Do this next** are on Growth and Pro (and during the 14-day Pro trial). #### Find the cause 1. **Open the incident** from Home. **What happened** gives the numbers, for example *POST /api/orders failed 106 of 302 requests (35%), normally 0.4%*. 2. **Read How it unfolded.** It starts with the likely origin. When a deploy landed just before the failures, **Recent changes** shows it, for example *api deployed 1.11.0 (was 1.10.1)*. 3. **Read the error.** The incident names the exception and, when the stack trace has it, the file and line (for example a `KeyError` in `service.py`, line 88). 4. **Open a failing request** from the evidence to see the full trace: every step of the request and where it broke. 5. **Read Do this next.** When a backend failure starts right after a deploy, it says: *This started right after api 1.11.0 was deployed: check that release or roll back to 1.10.1.* > **Tip:** watch [How to read a production incident](https://youtu.be/5PDrogf7ZJU) (2 min). ##### How Relia knows about your deploys Relia sees a deploy when a service starts reporting a new version. The Node.js and Python SDKs read the version from `RELIA_RELEASE`, `SERVICE_VERSION` or `OTEL_SERVICE_VERSION`, else from your host's commit variable (for example `GITHUB_SHA`, `VERCEL_GIT_COMMIT_SHA`, `RENDER_GIT_COMMIT`), else from `.git` or your `package.json` (Python: `pyproject.toml`) version. If your version never changes between releases, set `RELIA_RELEASE` in your deploy, or report deploys to Relia yourself. See [Report changes](https://tryrelia.com/docs/report-changes-api.md). #### Fix it You have two choices: - **Roll back** to the previous version named in **Do this next**. This is the fastest way to stop the damage. - **Fix forward.** Click **Show how to fix** on the incident (Growth and Pro). It writes concrete steps from the evidence: where (file and line, table or setting) and what to change. **Copy for your AI assistant** copies a brief you can paste into Claude Code, Cursor or another assistant. You can also fix it from your editor: connect your AI assistant to Relia and ask it to fix the incident. See [Fix from your editor](https://tryrelia.com/docs/from-your-editor.md). Relia never changes your code and has no access to your repository. #### Check the fix worked You don't need to tell Relia about the new deploy. When a new version of the affected service goes live after the incident began, Relia picks it up and starts checking your fix on real traffic. If you fixed it some other way (a config change, a rollback that reuses an old version), click **I fixed it** on the incident. The incident's fix box then shows **Checking your fix**. Relia confirms the fix once the problem stays away for at least 15 minutes with at least 20 requests on the affected APIs. Then: - The box says **Fix confirmed**, the incident is resolved, and Home's **This week** lists *Fix confirmed*. - You get a message: *Your fix worked*. If the problem shows up again after your fix, you get *Still happening after your fix* instead. If there isn't enough traffic within 24 hours to tell, the box says **Not confirmed yet**. > **Tip:** watch [From alert to verified fix](https://youtu.be/gtORFurIkow) (2 min). #### Next - [Did my deploy break anything?](https://tryrelia.com/docs/did-my-deploy-break.md) - [Fix it and confirm the fix](https://tryrelia.com/docs/fix-and-verify.md) - [Teach Relia what matters](https://tryrelia.com/docs/teach-relia.md): mark checkout as something that must never break. - [Write a postmortem](https://tryrelia.com/docs/postmortems.md) ### Why is my API slow? > When an API gets slower than its normal, find the step a slow request waits on (often one database query), change it, and let Relia confirm the speed is back. Section: Find and fix real problems · Page: https://tryrelia.com/docs/slow-api · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/W8ONSladzPk A page that used to load fast now takes seconds. Usually one API behind it got slow, and usually that API is waiting on one thing: a database query, another service or an outside API. This page shows how to find that one thing. The example is Relia's demo shop: at 13:00 the order page takes 2 seconds to load because `GET /api/orders/:id` got slow. #### What you'll see - **Home** shows the slow API under **For you** or **Worth watching**, for example *GET /api/orders/:id got slow*. **APIs** turns **Watch**: slow, not broken. - A slowdown alone is usually **Watch**. It becomes **Needs you** when it also comes with failures or with users struggling, or when the API is one you told Relia must never break. Relia compares the time 95% of requests finish within (the p95) with that route's normal. It flags a route only when the p95 is at least 500 ms, at least twice its normal and at least 300 ms slower. The normal takes the time of day and day of the week into account, so a busy Monday morning is compared with other Monday mornings. #### Find the cause 1. **Open the incident.** It gives the numbers, for example *p95 2,300 ms, normally 130 ms*. **Normal at this hour** shows what the route usually does on this weekday and hour. 2. **Go to APIs, then Performance.** Under **Slowest Endpoints by Average Latency**, find the API. Click it to narrow the list of requests below to that API. 3. **Open one of its slowest requests.** The **Execution Trace Waterfall** shows every step of that request as a bar: database queries, calls to other services and outside APIs. The longest bar is what the request waits on. 4. **Hover the long step to read it.** Database queries are shown with their values removed (`?` instead of ids and text), so you can see the query's shape safely. > **Tip:** the incident's **Do this next** gives the same advice: *Open a slow request to the API and see what it waits on (database or another service).* #### Fix it What to change depends on what the request waits on: | The long step is | Common fixes | |---|---| | One slow database query | Add an index on the columns it filters or joins on; drop joins the page doesn't need; select fewer columns. | | The same query many times | Load the rows in one query. See [Slow database queries and N+1](https://tryrelia.com/docs/slow-database-queries.md). | | A call to an outside API | Add a timeout and a fallback; check the provider's status page. See [Payment provider failing](https://tryrelia.com/docs/payment-provider-failing.md). | | Your own code (no long child step) | Look for heavy loops or large payloads in that handler. | On Growth and Pro, **Show how to fix** on the incident turns the evidence into concrete steps, and **Copy for your AI assistant** copies a brief for Claude Code, Cursor or another assistant. #### Check the fix worked Deploy your change. Relia picks up a new version of the affected service by itself; otherwise click **I fixed it** on the incident. Relia then watches real traffic. Once the problem stays away for at least 15 minutes with at least 20 requests, the incident says **Fix confirmed** and you get *Your fix worked*. If it gets slow again, you get *Still happening after your fix*. > **Tip:** watch [From alert to verified fix](https://youtu.be/gtORFurIkow) (2 min). #### Next - [Slow database queries and N+1](https://tryrelia.com/docs/slow-database-queries.md) - [APIs: requests, errors, logs and latency](https://tryrelia.com/docs/apis.md) - [Did my deploy break anything?](https://tryrelia.com/docs/did-my-deploy-break.md) ### Payments failing? Check if it's your provider > When calls to an outside service (payments, email, an AI API) start failing, see that the error comes from the provider, not your code, and what to check. Section: Find and fix real problems · Page: https://tryrelia.com/docs/payment-provider-failing · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/Xbx2NFRn4dg Your app depends on outside services: a payment provider, an email API, a model provider, a maps API. When one of them fails, your own requests fail too, and it can look like a bug in your code. Relia shows which side the error starts on. The example is Relia's demo shop: at 18:00 shoppers press **Pay now** and get an error, because the payment provider answers most charges with an error. #### What you'll see - **Home** says something needs you, for example *Calls from api to payments.example-pay.com are failing*. - The incident's chip says **Dependencies**: a service your app calls. - Your own API that makes those calls usually fails at the same rate, and it is part of the same incident. Relia watches every outgoing call your services make, grouped by the address they call. A dependency is flagged when its calls fail at least 3 times, at least 5% of the time and at least twice as often as usual, or when at least 2 calls fail and half or more of all calls fail. It also flags a dependency that gets much slower (p95 over 1 second and 3 times its usual). > **Note:** On the Free plan an incident shows its headline and numbers. The evidence, the cause chain and **Do this next** are on Growth and Pro (and during the 14-day Pro trial). #### Find the cause 1. **Open the incident.** **What happened** gives the numbers, for example *failed 25 of 42 times (60%), normally 0%*. 2. **Read Why Relia thinks so.** It explains why the dependency and your failing API belong together: *this service calls that dependency*. 3. **Open a failed request** from the evidence. In the trace, find the outgoing call (for example `POST /v1/charges`). If that call returned an error (a 502 after more than two seconds, say) and your code only passed the error on, the problem starts at the provider. 4. **Open Map** in the menu to see every outside service your app calls, with its calls, errors and speed. > **Tip:** watch [How to read a production incident](https://youtu.be/5PDrogf7ZJU) (2 min). #### Fix it **Do this next** tells you what to check: - **The provider's status page.** If they report an outage, there is nothing to fix in your code. Wait, and tell your customers if it lasts. See [Status page](https://tryrelia.com/docs/status-page.md). - **Your API key and credentials.** An expired key, a revoked key or a test key in production gives errors that look like an outage. - **The error the provider returns.** Open the failing call in a trace: the status code and error tell you whether it's a limit (429), bad input (400) or their server (5xx). To make your app handle the next outage better: - Put a timeout on calls to the provider, so users don't wait for seconds before seeing an error. - Show a clear message ("Payment didn't go through, please try again") instead of a generic error, so people don't press the button again and again. - Retry only where it is safe. A payment retry needs an idempotency key so a card is never charged twice. #### Check the fix worked - **If the provider recovers on its own:** the calls start working again and the incident goes quiet by itself. Home's **This week** lists it as *Went quiet*. - **If you changed something** (a new key, a timeout, a retry): deploy it. Relia picks up the new version by itself, or click **I fixed it** on the incident. Once the problem stays away for at least 15 minutes with enough traffic, the incident says **Fix confirmed** and you get *Your fix worked*. #### Next - [Why is my API slow?](https://tryrelia.com/docs/slow-api.md) - [Read an incident](https://tryrelia.com/docs/incidents.md) - [Status page](https://tryrelia.com/docs/status-page.md) ### Find slow database queries and N+1 problems > Use the Database page to find the queries that cost your app the most time, spot the same query repeated inside one request (N+1), and fix it. Section: Find and fix real problems · Page: https://tryrelia.com/docs/slow-database-queries · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/igeM6t6GH6U A page gets slower as the data grows: the more items in a cart or rows in a list, the longer it takes. The usual cause is an N+1: the code asks the database once per item instead of once for the whole list. Other times it's one query that got slow. This page shows how to find both. The example is Relia's demo shop: the cart page runs the same product query once per item, up to 14 times per request. #### What you'll see - **Home** shows it under **For you** or **Worth watching**, for example *GET /api/cart repeats the same database query (N+1)*. **Database** turns **Watch**. - Slow queries show up as *Slow database queries in api (postgresql)* when a query's p95 passes 1 second and is at least 3 times its usual. Relia flags an N+1 when the same query runs many times inside one request, in at least 2 requests, and the repeats cost at least 200 ms per request. On its own this is **Watch**: slow, not broken. It becomes **Needs you** when it comes with failures or users struggling. Relia records database calls made inside a request or a background job, from the Node.js, Python and PHP SDKs. Query values are removed before anything leaves your server, so you see `WHERE id = ?`, never the real ids, emails or text. #### Find the cause 1. **Open Database** in the menu. It lists every query your services run, grouped by shape, with the values removed. The top shows calls, failures and the slowest query. 2. **Read Repeated queries (N+1).** Each row names the API, how many times the query repeats in one request and how much of the request's time it takes, for example *up to 14 times per request, 260 ms, almost 90% of the request*. 3. **Click Example requests** to open real requests. In the trace you see the same query bar repeated one after another. 4. **Read Queries, most total time first.** A query can be fast alone and still cost the most because it runs so often. Click a query to see its p50, p95 and p99, its trend, and failed or slow example requests. 5. **Read Tables and collections, most time first** to see which table your app spends the most time on, with reads, writes and failures. > **Tip:** watch [Database monitoring for Postgres, MongoDB and Supabase](https://youtu.be/zpZNjfd7mVk) (2 min). #### Fix it - **N+1:** load the rows in one query instead of one per item, for example `WHERE id IN (...)` or a join. With an ORM, use its eager-loading option (`include`, `select_related`, `with`, `prefetch_related` and so on). 14 trips become one. - **One slow query:** add an index on the columns it filters, joins or sorts on. On Postgres, run `EXPLAIN ANALYZE` on the query to see where the time goes. - **A query that runs too often:** cache the result, or fetch it once per request instead of in every function that needs it. On Growth and Pro, **Show how to fix** on the incident writes the steps from the evidence, and **Copy for your AI assistant** copies a brief for Claude Code, Cursor or another assistant. ##### Using Supabase or Postgres? On the Database page you can also **Connect** your database with a read-only statistics login. The page then shows connections, the database size, the most expensive queries as Postgres measures them, and scheduled jobs (pg_cron). Relia also tells you when a scheduled job fails or stops running, or when the database is running out of connections. See [Database monitoring](https://tryrelia.com/docs/database.md). #### Check the fix worked Deploy your change. Relia picks up the new version of the service by itself, or click **I fixed it** on the incident. Relia then watches real traffic. Once the problem stays away for at least 15 minutes with at least 20 requests, the incident says **Fix confirmed** and you get *Your fix worked*. On the Database page, the repeated query drops out of **Repeated queries (N+1)**. #### Next - [Why is my API slow?](https://tryrelia.com/docs/slow-api.md) - [Database monitoring](https://tryrelia.com/docs/database.md) - [Fix it and confirm the fix](https://tryrelia.com/docs/fix-and-verify.md) ### Server running out of memory or disk > Relia warns you when a server's memory keeps climbing or its disk is filling up, tells you roughly when it will run out, and what to look for before it crashes. Section: Find and fix real problems · Page: https://tryrelia.com/docs/server-memory-disk · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/cn-cF38dUgU A server rarely runs out of memory or disk all at once. Memory climbs a little every hour; a disk fills a little every day. Relia watches the trend and warns you before the server falls over. The example is Relia's demo shop: from 03:00 on a Monday, memory on the server `api-2` climbs hour after hour. #### Before you start Server numbers (CPU, memory, disk) come from Relia's Node.js and Python SDKs, from each server your app runs on. Serverless functions (Vercel, Firebase, Lambda and so on) have no server of their own to watch, so this page doesn't apply to them. #### What you'll see Relia raises a server in steps: | What happens | What Relia shows | |---|---| | Memory or disk passes 80% | **Servers** turns **Watch** on Home under **Your product right now**. | | Memory keeps growing steadily (a possible leak) | An incident: *Memory on api-2 keeps growing (possible leak)*, with the rate and when it will reach 90%. | | A disk is filling up | An incident: *Disk on web-1 will be full soon*, with the expected day. | | Memory or disk reaches 90% | **Servers** turns **Needs you**. | | CPU peaks at 90% or stays high | An incident: *Server api-2 is overloaded (CPU)*. | The forecasts are what make the early warning: - **Memory:** Relia looks at the last 24 hours. If memory is above 50%, has risen most hours, and is on track to reach 90% within 3 days, it opens an incident. If that's within 24 hours, it **Needs you**; otherwise it's **Watch**. - **Disk:** if a disk will be 95% full within 7 days, Relia tells you the day. Within 24 hours it **Needs you**. #### Find the cause 1. **Open the incident.** It gives the numbers, for example *82% now, plus 5.5% an hour, so 90% around 09:20*. 2. **Open Servers** in the menu. Pick the server to see its CPU, memory and disk charts over time. A line that climbs steadily for hours is a leak; a sudden jump is usually one heavy job or request. 3. **Check Recent changes on the incident.** A restart or a deploy shows there as context. If memory drops back after every restart and then climbs again, something in your code keeps growing. > **Tip:** watch [Monitor server CPU, memory and disk](https://youtu.be/v08p3Z7U4Cc) (2 min). To leave development machines out of the Servers page, use its **Hosts** control. Servers that report a development environment are left out by default. #### Fix it **Memory that only grows** usually means a leak in your code. Look for: - caches or lists that only ever grow (add a size limit or an expiry), - event listeners or timers that are added on every request and never removed, - large objects kept in module-level variables. Restarting the service buys time, but the fix is in the code. If memory is simply too small for normal traffic, give the server more memory. **A disk that keeps filling:** - rotate logs or ship them elsewhere, - clear old builds, Docker images and temp files, - or grow the disk. On Growth and Pro, **Show how to fix** on the incident turns the evidence into concrete steps. #### Check the fix worked Deploy your fix. Relia picks up the new version by itself, or click **I fixed it** on the incident. Server problems have no request count to wait for, so Relia confirms the fix after 30 quiet minutes with no sign of the problem. Then the incident says **Fix confirmed** and you get *Your fix worked*. Keep an eye on the server's memory chart for a few hours too: a slow leak can take a while to show again. #### Next - [Monitor server CPU, memory and disk](https://tryrelia.com/docs/servers.md) - [Choose how Relia reaches you](https://tryrelia.com/docs/notifications.md) - [Set up on-call](https://tryrelia.com/docs/on-call.md) ### Website down? Find out before your customers do > Add an uptime monitor so Relia checks your site from outside every minute, alerts you when it stops answering, and can tell your customers on your status page. Section: Find and fix real problems · Page: https://tryrelia.com/docs/site-down · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/Joe6bAUjos8 When your whole site stops answering, your app can't report anything: there is no request to record. So Relia also checks your site from outside, the way a customer would, and tells you when it doesn't answer. The example is Relia's demo shop: one afternoon the storefront stops answering for fourteen minutes. #### Before you start: add a monitor 1. Open **Uptime & checks** in the menu. 2. Click **Add a monitor**. 3. Paste your site's address (for example `https://shop.example.com`), or a health address of your API. 4. Choose **How often to check** (every minute by default) and click **Add monitor**. Free has 5 monitors, Growth 20, Pro 50. Monitors only reach public addresses. > **Tip:** watch [Uptime monitoring and synthetic checks for your website](https://youtu.be/LDWbshEEOvk) (2 min). #### What you'll see One failed check could be a blip, so Relia waits for a second. **Two failed checks in a row** and your site is down: - You get an e-mail at once (and Slack, ClickUp or Jira on Growth and Pro, if you set them up). You get one more when the site recovers. - **Home** says something needs you, for example *shop.example.com is unreachable*. The chip says **Outside**: Relia saw it from outside, like your customers. - **Uptime & checks** shows **Needs you**. On the monitor's bar each block is one check; the red ones are the outage. A site that is down is always **Needs you**. #### Find the cause 1. **Open the incident.** **What happened** says the site is down and how it failed: no response, a timeout, or an error status such as `HTTP 502`. 2. **Read Do this next:** check that the server is running and reachable: the process, the port, DNS, the TLS certificate and the firewall. 3. **Look at the evidence from inside.** If Relia's SDK runs on that server, the incident also shows what failed inside at the same time (errors, a database that stopped answering, a full disk). No data at all from inside usually means the process or the machine is down. Common causes: the app crashed and didn't restart, a deploy failed halfway, the server ran out of memory or disk, an expired TLS certificate, a DNS change, or your hosting provider is down. #### Tell your customers If you have a public status page, Relia can post the outage for you in plain words, for example *Storefront is unavailable. We are looking into it.* It never shows internal details like routes, servers or error counts. - With **Post outages automatically** switched on in the status page setup, Relia posts by itself. - Otherwise Relia asks you first. When the site answers again, the post turns to resolved and the page says all systems are operational. See [Create a status page](https://tryrelia.com/docs/status-page.md). > **Tip:** watch [Create a public status page with your own domain](https://youtu.be/82-Mi35wfrE) (2 min). #### Fix it Fix what stopped the site (restart the process, roll back the deploy, renew the certificate, free disk space), then make it less likely next time: - run the app under a process manager or platform that restarts it when it crashes, - monitor a health address that checks your database too, not only that the web server answers, - set up [on-call](https://tryrelia.com/docs/on-call.md) so someone is paged at night. #### Check the fix worked You don't need to do anything. Relia keeps checking: as soon as the site answers again you get the "recovered" message, and the incident closes on its own 30 minutes after the last failed check. It then says how long the site was down, for example *was down for 14 min*. Home's **This week** lists it. #### Next - [Uptime monitors and Relia's checks](https://tryrelia.com/docs/uptime-and-checks.md) - [Create a status page](https://tryrelia.com/docs/status-page.md) - [Choose how Relia reaches you](https://tryrelia.com/docs/notifications.md) ### Fix JavaScript errors in production > When users hit a JavaScript error in the browser, see what they were doing, read the stack trace in your own source files, and confirm the fix on real traffic. Section: Find and fix real problems · Page: https://tryrelia.com/docs/javascript-errors · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/DrD9OWbQ_nQ A browser error often shows up to users as something quietly missing: a blank card, a button that does nothing, a page that never finishes. Relia's browser SDK records these errors with what the user did just before, so you can find the line that broke. The example is Relia's demo shop: on a product page the product card comes up blank, because the code reads `price` from something that is `undefined`. #### Before you start - Relia's browser SDK in your web app. See [Watch your web app](https://tryrelia.com/docs/web-app-setup.md). - For readable stack traces: source maps uploaded for each build (below). Without them the stack points into minified code. #### What you'll see - **Home** says something needs you, for example *Users hit a JavaScript error on /products/:id (TypeError: Cannot read properties of undefined (reading 'price'))*. **Users** shows **Needs you**. - A browser error alone becomes **Needs you** once at least 3 different people hit it. When the error comes with a failing API request in the same visit, Relia joins them into one incident. #### Find the cause 1. **Open the incident.** It names the error, the page and how many people hit it. 2. **Open a visit.** Go to **Users**, then **Sessions**, find a visit that ended in the error and click **View**. 3. **Read the Timeline.** It shows the pages, clicks and requests in order, so you can see what happened right before the error. 4. **Open Console.** The **Console Error** shows the message and the stack. With source maps, the top frame is your own file, line and function (for example `src/components/ProductCard.tsx:42 in renderPriceBadge`) with the code around it. **Show minified stack** still shows the original. 5. **Read Do this next.** With source maps it points straight at the line: *Fix TypeError: … at src/components/ProductCard.tsx:42 (in renderPriceBadge).* #### Get readable stack traces (source maps) If the stack points into a bundle like `index-a8f3.js:1`, upload your source maps. `npx relia-sdk@latest init` sets this up for you when it sets up a web app. To do it by hand: **Vite:** add the plugin to `vite.config`: ```ts // vite.config.ts import { reliaSourcemaps } from "relia-sdk/vite" export default { plugins: [reliaSourcemaps({ projectId: "YOUR_PROJECT_ID" })] } ``` **Any other build:** upload after you build: ```bash npx relia-sdk@latest sourcemaps upload ./dist --project-id YOUR_PROJECT_ID ``` Maps are uploaded after the build and then removed from the output, so your source code is never published. Uploading needs `RELIA_TOKEN` (an upload-only token written to `.env.local` by setup; run `npx relia-sdk@latest token` to make one). On a hosted build (Vercel, Netlify, Render, CI), add `RELIA_TOKEN` to the host's environment variables, or those builds skip the upload. Source maps apply to errors from the build they were uploaded for, so the next error after you upload will be readable. > **Tip:** watch [Browser errors show minified code? Upload source maps to fix it](https://youtu.be/ArLJuvippU8) (2 min). #### Fix it Fix the line the stack points at. For errors like *Cannot read properties of undefined*, check where the value comes from: an API that sometimes returns less data, a field that was renamed, or data used before it has loaded. On Growth and Pro, **Show how to fix** on the incident writes steps from the evidence, including the browser code location, and **Copy for your AI assistant** copies a brief for Claude Code, Cursor or another assistant. #### Check the fix worked Ship the fix, then click **I fixed it** on the incident. Relia picks up new versions of your server by itself, but a change that only touches the browser code needs this click. Relia watches real visits. Once the error stays away for 30 minutes, the incident says **Fix confirmed** and you get *Your fix worked*. If people hit it again, you get *Still happening after your fix*. #### Next - [Upload source maps](https://tryrelia.com/docs/source-maps.md) - [Find where users get stuck](https://tryrelia.com/docs/users-stuck.md) - [Identify your users](https://tryrelia.com/docs/identify-users.md): see which customers an error hit. ### Find where users get stuck or rage-click > Relia spots clicks that do nothing, repeated clicks and pages people get stuck on, and suggests what to change in your UI, with real visits as proof. Section: Find and fix real problems · Page: https://tryrelia.com/docs/users-stuck · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/lDKUAvX2xSE Not every problem is an error. Sometimes nothing is broken, but people click something that doesn't respond, press a button again and again, or go back and forth without getting anywhere. Relia finds these places from real visits and tells you what to change. The example is Relia's demo shop: on the product list, people click a row and nothing opens; on search, people press **Search** several times because nothing shows it's working. #### Before you start Relia's browser SDK in your web app. See [Watch your web app](https://tryrelia.com/docs/web-app-setup.md). It records clicks, pages and form submits, never the text people type. #### What you'll see - **Home** may still say *All good*: nothing is broken. Under **What to change in the UI**, Relia lists its top suggestions. **All suggestions** opens the full list. - When the friction is strong, it also becomes an incident, for example *Users rage-click 'Search' on /search* or *Users get stuck on /checkout*. Friction alone needs at least 3 different people before it **Needs you**; with fewer it's **Watch** or less, because two people is often your own team testing. #### Find the cause 1. **Open Users, then UX issues** (or click **All suggestions** on Home). This page shows where people struggle: clicks that do nothing, repeated clicks, pages they get stuck on. 2. **Read What to change.** Each suggestion comes from at least 3 people or at least 5 occurrences, and names the place, how many people and the change to make. The kinds are: | Suggestion | What people did | |---|---| | **Rows people expect to open** | Clicked rows of a table or list, and nothing opened. | | **Looks clickable, does nothing** | Clicked something that looks like a link or button but isn't. | | **No feedback after pressing** | Pressed the same button several times quickly (rage clicks). | | **People get stuck** | Repeated actions on a page without moving forward. | | **Back and forth between pages** | Went between the same pages again and again. | | **Slow page** | Waited on a page that loads slowly. | 3. **Watch the proof.** Open one of the example visits. The timeline shows exactly what happened, for example four presses on **Search** within one second. In a visit's timeline you can filter to **Rage Clicks** or **Dead Clicks**. > **Tip:** watch [Visitors, sessions and Core Web Vitals explained](https://youtu.be/IHWdb_QoTx8) (2 min). #### Fix it The suggestion says what to change. Typical changes: - **Rows that don't open:** make the whole row open the item, or make the name a clear link, and show a pointer cursor on hover. - **Buttons pressed again and again:** show a loading state as soon as the button is pressed, and disable it until the answer comes back. - **Things that look clickable:** make them work, or style them so they don't look like links. - **Stuck pages:** walk through the page yourself on a phone and a slow connection; look for a hidden error message or a step that isn't clear. #### Check the fix worked - **Suggestions:** once your change is live, click **Done** on the suggestion. If people still hit the same thing a day later, it comes back. **Not a problem** hides it for good. - **Incidents:** click **I fixed it** on the incident. Relia watches real visits and, once the friction stays away for 30 minutes, says **Fix confirmed** and sends *Your fix worked*. #### Next - [Funnels: where people leave your journeys](https://tryrelia.com/docs/funnel-drop-off.md) - [Fix JavaScript errors](https://tryrelia.com/docs/javascript-errors.md) - [Users and visitors](https://tryrelia.com/docs/users-and-visitors.md) ### Why do users drop off? > When fewer people finish a journey like checkout or sign-up, find the step where they leave, see why, fix it and watch conversion come back. Section: Find and fix real problems · Page: https://tryrelia.com/docs/funnel-drop-off · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/lgeD_XG2fz8 Sometimes nothing looks broken, but fewer people finish what they came to do: fewer orders, fewer sign-ups. Relia counts every visit through your main journeys (funnels), notices when fewer people finish, and shows where and why they leave. The example is Relia's demo shop: fewer shoppers search, open a product and save it to their wishlist, because the search request has started failing. #### Before you start - Relia's browser SDK in your web app. See [Watch your web app](https://tryrelia.com/docs/web-app-setup.md). - A funnel for the journey. Relia finds your main journeys itself (checkout, sign-up, upgrade, contact and so on) once at least 20 people have finished one in the last 7 days. On Growth and Pro you can also make your own under **Users**, then **Funnels**, with **New funnel**. #### What you'll see - **Home** shows it under **For you** or **Worth watching**, for example *Fewer people finish the Wishlist journey: they are lost after Search*. **Users** turns **Watch** (or **Needs you**). - Relia compares each watched funnel's last hour with the same hour on the previous 7 days. When the share of people who finish falls by at least 40% (and at least 30 people started), it opens an incident naming the step that lost them. Checkout, sign-up and upgrade journeys count as **Needs you**; others are **Watch**. - A slow decline week after week shows on Home under the funnels, and turns **Users** amber. Free watches 3 funnels for drops, Growth 10, Pro 30. #### Find the cause 1. **Open the incident.** It gives the numbers, for example *under 10% finished in the last hour, against 21% usually at this hour*, and links to the funnel. 2. **Open the funnel** (or go to **Users**, then **Funnels**). Each step is a bar: how many people reached it and how many went on. The biggest drop is marked. 3. **Click why?** next to *N left here* under the step that loses people (Growth and Pro). Relia compares those who left with those who went on and lists what stands out: - where they went instead, and where they came from, - requests that failed and JavaScript errors right after the step, - a slow page, rage clicks, dead clicks, or people getting stuck, - form fields the browser refused, - devices, browsers or countries where people leave more often, - open problems on that page or the next API, - visits to watch. When nothing stands out, it says so plainly instead of guessing. 4. **Watch one of the visits.** You see exactly what happened, for example: they search, the results never come, they leave. > **Tip:** watch [Visitors, sessions and Core Web Vitals explained](https://youtu.be/IHWdb_QoTx8) (2 min). #### Fix it Fix what the panel points at. Often it's an existing problem: a failing request (open its incident and follow [Read an incident](https://tryrelia.com/docs/incidents.md)), a JavaScript error ([Fix JavaScript errors](https://tryrelia.com/docs/javascript-errors.md)), a slow page, or a confusing step ([Find where users get stuck](https://tryrelia.com/docs/users-stuck.md)). If a recent change to that page lines up with the drop, check that change first. #### Check the fix worked - If the cause was an incident, ship the fix and click **I fixed it** on that incident. Relia watches real traffic and tells you *Your fix worked* or *Still happening after your fix*. - On the funnel page, **Conversion over time** shows the rate climb back to its usual level. Pick a period (24 hours, 7, 30 or 90 days, or custom dates) and compare it with the period before. #### Next - [Find where users get stuck](https://tryrelia.com/docs/users-stuck.md) - [Teach Relia what matters](https://tryrelia.com/docs/teach-relia.md): mark your key journey's pages as must-never-break. - [Ask Relia](https://tryrelia.com/docs/ask-relia.md): ask "where do people leave sign-up?" ### Fix pages and APIs returning 404 not found > Find which visitors land on "not found", which request failed, where they came from, and fix the link or the API that sends them there. Section: Find and fix real problems · Page: https://tryrelia.com/docs/not-found-errors · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/ed4I6yqAPXc A 404 means "not found": the page or the thing a request asked for doesn't exist. Your server isn't crashing, so it's easy to miss, but for the visitor the page is broken. Common causes are an old link to something you deleted or renamed, a typo in a URL your app builds, or a route that moved. The example is Relia's demo shop: an old social media post links to a product that no longer exists, so visitors land on a product page whose request comes back 404. #### What you'll see - **Home** says something needs you, for example *Users get errors from GET /api/products/:id on /products/:id*. **Users** shows **Needs you**. - **APIs** usually stays normal: a 404 is the server answering correctly, not a server error. - Relia raises it as **Needs you** once at least 3 different visitors hit it. With fewer it stays quiet or **Watch**, since one or two can be a typo or your own testing. > **Note:** 401 and 403 answers (signed out, not allowed) are treated differently: they are usually a page asking for data before the user signs in, so Relia keeps them as information, not alerts. #### Find the cause 1. **Open the incident.** It says how many visitors opened the page and had the request fail, and each visit links to its session. 2. **Open a visit, then Network.** Find the request that came back `404`, for example `GET /api/products/1009`. That tells you exactly what was missing. 3. **Open Device & User.** The **referrer** shows where the visitor came from: a social post, a search engine, an email, another site, or a page of your own app. 4. **See how often it happens.** Go to **APIs**, then **Errors**, and choose the **4xx Client Errors** filter. It groups client errors such as 404 by API, with how many there were and when they were last seen. > **Tip:** watch [Monitor API requests, errors, logs and latency in one place](https://youtu.be/W_SUfdKLns0) (2 min). #### Fix it Decide which side is wrong: | What you found | What to do | |---|---| | The link points to something that was deleted or renamed | Fix the link where it lives (the post, the email, your own page), or redirect the old address to something that exists. | | Your app builds the wrong URL | Fix the code that builds it (a missing id, a wrong path). | | The API route moved | Keep the old route answering, or redirect it, until old clients stop using it. | | The item really is gone | Show a helpful "not found" page with links onward, instead of a blank or broken page. | **Do this next** on the incident says to fix the API. Read it together with the referrer: when the API answers correctly and the item is simply gone, the fix is usually the link, not the API. #### Check the fix worked Once the link or redirect is fixed, click **I fixed it** on the incident. Relia watches real visits. After 30 minutes with no new errors it says **Fix confirmed** and sends *Your fix worked*. If visitors hit it again, you get *Still happening after your fix*. #### Next - [Fix JavaScript errors](https://tryrelia.com/docs/javascript-errors.md) - [Teach Relia when an alert is wrong](https://tryrelia.com/docs/feedback.md): mark a 404 that is expected so it stops coming back. - [Users and visitors](https://tryrelia.com/docs/users-and-visitors.md) ### AI feature failing or costing too much > Find why the AI feature in your product fails (often a provider error like a rate limit), catch a cost spike before the bill does, and see which of your MCP tools fail for AI assistants. Section: Find and fix real problems · Page: https://tryrelia.com/docs/ai-feature-failing · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/OCDIWdXLIQs AI features fail in their own ways: the model provider refuses a call, a loop sends far more tokens than it should, or a tool the model calls breaks. Relia records every model call your product makes as a **run**, with its steps, tokens, estimated cost and whether it failed, and raises the problems. The example is Relia's demo shop: its support assistant sometimes gives no answer, has started costing far more than usual, and one of its MCP tools fails. #### Before you start - Relia's server SDK in the app that calls the model: `relia-sdk` 0.8 or later for Node.js (`npm i relia-sdk@latest`), 0.6 or later for Python (`pip install -U relia-sdk`). Calls to OpenAI, Anthropic, Gemini, OpenRouter and other common providers are recorded with no code change. See [Monitor AI calls in your app](https://tryrelia.com/docs/ai-calls-setup.md). - Costs are estimates from public list prices. A model Relia doesn't know is counted at zero cost rather than a guess. #### What you'll see Relia raises three kinds of AI problems, all under the **AI in your product** part on Home: | Problem | Example headline | Level | |---|---|---| | Runs fail | *Your AI agent support-bot is failing* | **Needs you** once at least 3 runs fail | | Spend jumps | *Your AI agent support-bot is costing far more than usual* | **Watch** | | An MCP tool fails | *Your MCP tool search_products fails for AI assistants (claude-code)* | **Needs you** once at least 3 calls fail | A cost spike means at least $1 and at least 3 times the usual spend for the same length of time (or at least $5 when there is no history yet). A failing MCP tool means at least 3 failed calls that are either at least 10% of its calls and twice its usual share, or half or more of all its calls. Relia also flags runs and tools that get much slower. #### Find the cause ##### Failing runs 1. **Open the incident.** It gives the numbers, for example *failed 11 of 184 runs (6%)*. **Do this next** says to open the failing runs and check the model provider error (API key, quota, timeout). 2. **Open AI in your product, then Runs**, and choose **Errors Only**. 3. **Click a failed run.** Its steps show each model call and tool call in order. The failed step shows the error, for example *rate limited by provider, 429*. Common provider errors: `429` (rate limit or quota used up), `401` (a wrong or revoked API key), `400` (a request the model can't take, often a prompt that is too long), timeouts and `5xx` (the provider's side). ##### A cost spike 1. **Open the incident.** It compares spend with usual, for example *$8.70 in 190 runs, usually about $0.46*. 2. **Open Runs** and look at the **Cost (USD)** column: compare recent runs with older ones. 3. **Open Agent issues.** **Token Bloat** marks runs that used 50,000 tokens or more, or at least 3 times the agent's usual. ##### A failing MCP tool If your product offers tools to AI assistants through an MCP server, open **AI in your product**, then **Tool calls**. **Your MCP server** lists each tool with its calls, failures, p95 and **Called by** (which assistants called it). Click a tool to see its latest calls, and open one to see the error in its request. What the assistant asked and what the tool answered are never recorded. > **Tip:** watch [Monitor AI agents, LLM runs, tool calls and your MCP server](https://youtu.be/szMNhbJQauU) (2 min). #### Fix it - **Rate limit or quota:** check your quota with the provider, raise it, or add retries with backoff. Spread heavy work out instead of sending it all at once. - **Key errors:** replace the key in your host's environment variables. - **Cost spike:** look for a loop that repeats model calls, retries that pile up, a switch to a bigger model, or prompts that grew (for example a growing chat history). Cap the steps or tokens per run. - **Failing tool:** fix the error inside the tool. Assistants get it as an error answer and may give up. On Growth and Pro, **Show how to fix** on the incident writes steps from the evidence. #### Check the fix worked Deploy your change. Relia picks up a new version of the service by itself, or click **I fixed it** on the incident. Relia watches real runs and calls and tells you *Your fix worked* or *Still happening after your fix*. #### Next - [Monitor AI in your product](https://tryrelia.com/docs/ai-in-your-product.md) - [Monitor AI calls with no code](https://tryrelia.com/docs/ai-calls-setup.md) - [Payment provider failing?](https://tryrelia.com/docs/payment-provider-failing.md): the same steps help when any outside API fails. ### Did my deploy break anything? > After a release, ask Relia whether anything got worse, compare before and after on a chart with the deploy marked, or run the same check from your editor. Section: Find and fix real problems · Page: https://tryrelia.com/docs/did-my-deploy-break · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/54eZKUa3EPs You just shipped. Nothing is on fire, but did anything get worse: new errors, a slower API, a slower page? This page shows three ways to check, and what Relia does on its own when a deploy does break something. The example is Relia's demo shop: it ships api 1.12 at 15:00. Nothing breaks, but the product list gets slower. #### Before you start Relia has to know about your deploys. It sees one when a service starts reporting a new version. The Node.js and Python SDKs read the version from `RELIA_RELEASE`, `SERVICE_VERSION` or `OTEL_SERVICE_VERSION`, else from your host's commit variable (for example `GITHUB_SHA`, `VERCEL_GIT_COMMIT_SHA`, `RENDER_GIT_COMMIT`), else from `.git` or your `package.json` (Python: `pyproject.toml`) version. If yours never changes, set `RELIA_RELEASE` in your deploy, or report each deploy yourself (see [Report changes](https://tryrelia.com/docs/report-changes-api.md)). #### What you'll see There is no separate release screen. A deploy shows up wherever it matters: - **When it breaks something:** Relia opens an incident on its own. If the problem started right after the deploy, **Recent changes** on the incident lists it, and **Do this next** names the release: *This started right after api 1.12 was deployed: check that release or roll back to 1.11.1.* See [A deploy broke something important](https://tryrelia.com/docs/deploy-broke-checkout.md). - **On dashboards you make:** on time charts, a deploy is a dashed line. Under a chart with one line, a sentence compares before and after, for example *response time is 71% higher since that deploy*. It only appears when the change is at least 20% and bigger than the chart's usual ups and downs. #### Find the cause ##### Ask Relia 1. Open **Ask Relia** in the menu. 2. Type your question and send it: ```text Did the last deploy cause any problems? ``` 3. Read the answer. It starts with a one-line verdict (for example *nothing broke, but the product list got slower*), then short points: new incidents, new errors, slower APIs. Each claim links to its evidence. 4. Ask a follow-up to see it on a chart, for example *show me the response time of GET /api/products over the last 6 hours*. To see the deploy marked on the chart, ask Relia to make a dashboard with it (for example *make me a dashboard for the product list*): dashboard charts mark deploys. Ask Relia is on every plan. Free includes 30 questions a month. > **Tip:** watch [Ask your production data questions in plain English](https://youtu.be/z3LCOFL7T_U) (2 min). ##### From your editor If your AI assistant is connected to Relia, run Relia's **deploy-check** prompt (in Claude Code: `/mcp__relia__deploy-check`), or just ask *did my last deploy break anything?*. It reads the recent changes, finds the latest deploy, and compares before and after: incidents, errors, slow requests and database queries. It tells you in plain words whether the deploy is fine, and if not, what broke and where in the code. > **Tip:** watch [Fix production bugs from your editor with Claude Code and Cursor](https://youtu.be/67fIYRYKZWk) (2 min). ##### On a dashboard Your service's dashboard (**Dashboards**, then the service) lists the versions it ran, with restarts. Charts in a dashboard you make (**Dashboards**, then **New dashboard**, or "make me a dashboard" in Ask Relia) mark each deploy with a dashed line. See [Dashboards](https://tryrelia.com/docs/dashboards.md). #### Fix it - **Something broke:** roll back to the previous version, or fix forward. On Growth and Pro, **Show how to fix** on the incident writes the steps. - **Something got slower:** open a slow request and see what it waits on. See [Why is my API slow?](https://tryrelia.com/docs/slow-api.md) #### Check the fix worked Ship the fix (for example api 1.12.1). Relia picks up the new version by itself and starts checking any open incident on real traffic: you get *Your fix worked* or *Still happening after your fix*. On a dashboard chart the new deploy is a second dashed line, and the sentence under it compares before and after the newest deploy. #### Next - [A deploy broke something important](https://tryrelia.com/docs/deploy-broke-checkout.md) - [Report deploys and changes](https://tryrelia.com/docs/report-changes-api.md) - [Ask Relia](https://tryrelia.com/docs/ask-relia.md) ### Users, visitors and page speed > Understand the Users pages: who visits your product, where their visits go wrong, and how fast your pages feel (LCP, INP, CLS). Section: Each part of Relia · Page: https://tryrelia.com/docs/users-and-visitors · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/IHWdb_QoTx8 The **Users** part of Relia shows the people using your product: how many come, where they come from, what they do, and where their visit goes wrong. It needs the browser SDK in your web app ([Set up a web app](https://tryrelia.com/docs/web-app-setup.md)). Open **Users** in the sidebar. Its pages are **Visitors**, **Sessions**, **Page speed**, **User flows**, **Funnels** and **UX issues**. **People** is its own item higher in the sidebar. #### Visitors **Visitors** counts the people the browser SDK saw. Bots and crawlers are left out, so the numbers can differ a little from other analytics tools. - **Period**: 24 hours, 7, 30 or 90 days, or custom dates inside your plan's history. Each number is compared with the same length of time just before. - **The numbers on top**: visitors, visits, page views, bounce rate, time per visit, and visits with an error. - **Where visitors hit problems**: pages and segments (a browser, a country, a device) that are clearly worse than the rest of your site. For example: "product pages take 3.4 s to show their main content; the site, 2.1 s". - **All pages**, **Sources** (where people come from, like Google or Instagram, and which countries) and **Technology** (devices, browsers, operating systems). Next to each row: **Speed** (LCP), **Errors** (share of visits with an error) and **Struggled** (rage clicks, dead clicks, stuck, loops). - **Filters**: click any row to see only those visitors. Filters stack and stay in the page address, so you can share the view. Only want visitor numbers for a marketing site? Choose **Page views only** in `npx relia-sdk@latest init`, or add `mode: "pageviews"` to `Relia.init`. It records page views, sources, devices, countries and errors, and counts 1 unit per page view. #### Sessions **Sessions** shows each visit as a journey: pages, clicks, form submits, errors and page speed, with the visit's length, device and location. A click is linked to the API request it made, so a failing button and a failing API become one problem. By default there is no screen recording: Relia keeps the journey, not a video. Replays only exist if your app's code turns them on with `replay: true`. #### People **People** lists the customers your app named with `Relia.identify`: their plan, sessions and errors. Search by e-mail, name or id. Open a person to see their sessions and plan over time. Owners and admins can **Export data** or **Erase identity** for a person. > **Tip:** watch [See which customers a bug hit: identify users in Relia](https://youtu.be/1mIOiHnI9nk) (2 min). #### Page speed (Web vitals) **Page speed** opens Web vitals. Each value is the 75th percentile (p75): 3 in 4 page views were this fast or faster. | Metric | What it measures | Good | Poor | |---|---|---|---| | LCP | How long until the main content shows | 2.5 s or less | over 4 s | | INP | How long the page takes to react to a click or key | 200 ms or less | over 500 ms | | CLS | How much the page jumps around while loading | 0.1 or less | over 0.25 | Relia also shows FCP (first content), TTFB (first byte from the server) and route changes in single-page apps. These follow Google's thresholds. **Pages, worst first** puts the slowest page on top. Open one to see the elements behind the slow or shifting views (for example, the product photo is the main content and it also moves while loading), with example sessions. A common fix: load that image first and give it a fixed size. #### User flows, Funnels and UX issues - **User flows** shows the journeys people take through your product and how many finish them. - **Funnels** shows how many people get through each step of a journey, like checkout, and why the others left. See [Users drop off in a funnel](https://tryrelia.com/docs/funnel-drop-off.md). - **UX issues** lists where people get stuck or rage-click, with **What to change**: suggestions such as "make the whole row open the item" when people keep clicking rows that do nothing. > **Tip:** watch [Find where users get stuck or rage-click in your app](https://youtu.be/lDKUAvX2xSE) (2 min). #### Privacy What people type is never sent: Relia only gets how many characters were typed. Visitor addresses are shortened before they are stored. See [Privacy](https://tryrelia.com/docs/privacy.md). #### Next - [Set up a web app](https://tryrelia.com/docs/web-app-setup.md) - [Identify your users](https://tryrelia.com/docs/identify-users.md) - [Fix JavaScript errors](https://tryrelia.com/docs/javascript-errors.md) - [Users stuck or rage-clicking](https://tryrelia.com/docs/users-stuck.md) ### APIs: requests, logs, errors and performance > Find your way around the APIs pages: every request, your warning and error logs, grouped errors, slow endpoints and the map of your services. Section: Each part of Relia · Page: https://tryrelia.com/docs/apis · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/W_SUfdKLns0 The **APIs** part of Relia shows what your server does: what came in, what broke, what's slow, and how your services connect. It fills in once a server SDK sends traces (Node.js, Next.js, Python, PHP / Laravel, or any language through OpenTelemetry). Open **APIs** in the sidebar. Its pages are **Requests**, **Logs**, **Performance**, **Errors** and **Anomalies**. **Map** is its own item higher in the sidebar. #### Requests **Requests** opens the **Logs & Requests** page. Every row is one request to your server: when, which endpoint, the status, how long it took and which service answered. Search (for example `products`) to see only matching requests, filter by service, status or time, and open a row to see the request's trace. The page has three tabs: - **HTTP / API Requests**: the request list. - **Process Logs**: the same requests as a log, with service, time, severity and trace id. - **Endpoint Analytics**: one row per endpoint with calls, average time and error rate. Open an endpoint for its calls, latency (p95, p99) and errors over time. Quick ranges go up to 7 days. #### Logs **Logs** shows the warning and error lines your services send, grouped into patterns: one row per kind of message, with how many lines, a trend, when it was last seen and a link to a request that logged it. Switch to **Lines** to read them one by one, newest first. Info and debug lines are not stored. The SDKs send warnings and errors by default; set `RELIA_LOGS=0` to stop sending logs. #### Errors **Errors** opens the **Issues** page. Each kind of error becomes one row, however often it happens, with when it was last seen and how many times. Open one for its events and the stack trace, pointing at the line in your code. Not every row is a fire. For example, about 3 in every 100 product requests asking for a product that doesn't exist (404) is worth a look, not an emergency. Relia's own incidents tell you which problems need you. > **Tip:** watch [Fix pages and APIs returning 404 not found in production](https://youtu.be/ed4I6yqAPXc) (2 min). #### Performance **Performance** ranks your slowest endpoints and shows latency over time. Open a request and the waterfall shows where the time goes: each step (your code, a database query, a call to another service) as a bar. Often one slow query explains a slow endpoint. > **Tip:** watch [Why is my API slow? Find the slow database query behind it](https://youtu.be/W8ONSladzPk) (2 min). #### Anomalies **Anomalies** lists slow calls, error bursts and traffic spikes. Most of these also show up as incidents on Home. #### Map **Map** shows how everything connects, in columns: users, your services, what they depend on (databases, queues, outside APIs, AI agents) and the servers they run on. Lines are coloured by health, and cards show open incidents. Click a card to see only its connections, its incidents and example failed requests. #### What Relia does with this You don't have to watch these pages. Relia reads the same data every few minutes and raises an incident when an endpoint fails or slows down more than usual for it. Look here when you want the detail behind an incident, or when your server acts up. #### Next - [Database](https://tryrelia.com/docs/database.md) - [Read an incident](https://tryrelia.com/docs/incidents.md) - [Why is my API slow?](https://tryrelia.com/docs/slow-api.md) - [Did my deploy break anything?](https://tryrelia.com/docs/did-my-deploy-break.md) ### Database monitoring > Read the Database page (queries, repeated queries, reads and writes, tables) and connect a Supabase or Postgres database to see inside it. Section: Each part of Relia · Page: https://tryrelia.com/docs/database · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/zpZNjfd7mVk The **Database** page lists every query your services run, grouped by shape with the values removed, so `SELECT * FROM orders WHERE id = 42` and `... id = 43` are one row. It works with Postgres, MySQL, MongoDB, Redis and the other databases the Relia SDKs trace, and with Supabase calls made from the browser. Open **Database** in the sidebar, under **Your product**. #### What the page shows - **Time range**: 1 hour, 6 hours, 24 hours, 7 days or 30 days. - **One card per database** your services use (for example Postgres and Redis). - **Four numbers**: how many different queries, how many calls, how many failed, and the slowest one. Zero failed calls is what you hope to see. - **Repeated queries (N+1)**: appears when one request runs the same query 10 or more times. It names the endpoint, how many times per request, how much of the request's time it takes, and links example requests. A typical case: a product list that loads each product's images one by one. - **What your services do with the database**: calls split into **Reads**, **Inserts**, **Updates** and **Deletes**, with failures and the slowest p95. - **Tables**: each table or collection, most time first, with reads, writes and failures. - **Every query**: how often it runs, how long it takes (p50, p95, p99) and total time. Click a row for its trend and example slow or failed requests. Statement values are masked by the SDK before anything leaves your server. Relia stores the shape of a query, not your data. > **Tip:** watch [Find slow database queries and N+1 problems in production](https://youtu.be/igeM6t6GH6U) (2 min). #### See inside a Supabase or Postgres database The page above shows queries as your app sees them. Connecting the database itself adds what Postgres measures: connections, database size, the most expensive queries, and scheduled jobs (pg_cron) that fail or stop running. This is available on every plan. ##### Before you start - You are an owner or admin of the Relia project. - You can run SQL in your database (in Supabase: the **SQL editor**). ##### Steps 1. On the **Database** page, find **See inside your Supabase / Postgres database** and click **Connect**. If Relia hasn't seen Postgres calls from your app yet, click the line **Using Supabase or Postgres? See inside your database** first. 2. Copy the SQL snippet Relia shows and run it once in your database. It creates a login called `relia_monitor` with a password made for you. No pg_cron? Skip the last two lines. 3. Copy the connection string. In Supabase: **Connect → Session pooler**, with the user `relia_monitor` and the password from the snippet. If your database has network restrictions, allow Relia's server first. 4. Paste it into Relia and click **Connect**. ##### What Relia's login can do The `relia_monitor` login reads statistics only. Relia refuses a login that can read your tables, create roles or bypass row-level security, and every connection is read-only. The connection string is stored encrypted. ##### Check it worked The page shows **Connections**, **Database size**, **Most expensive queries** and **Scheduled jobs (pg_cron)**. Relia reads them every 5 minutes; the first query numbers appear after two reads (about 10 minutes). With the database connected, Relia also raises incidents when a scheduled job fails or stops running, connections reach 80 % of the limit, or a query gets much slower than its usual day. #### If something's wrong - **The page is empty**: database calls are only recorded inside a request or a job. Check that your server SDK is sending requests first ([No data?](https://tryrelia.com/docs/no-data.md)). - **Connect is refused**: the login has more rights than statistics. Use the `relia_monitor` login from the snippet, not your admin user. - **No cron jobs listed**: pg_cron isn't installed, or the snippet's last two lines were skipped. #### Next - [Slow database queries](https://tryrelia.com/docs/slow-database-queries.md) - [Why is my API slow?](https://tryrelia.com/docs/slow-api.md) - [Set up a Supabase app](https://tryrelia.com/docs/supabase-setup.md) - [APIs](https://tryrelia.com/docs/apis.md) ### Servers: CPU, memory and disk > Read CPU, memory and disk for each of your servers, know when to look, and hide a laptop or test machine so it doesn't count. Section: Each part of Relia · Page: https://tryrelia.com/docs/servers · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/v08p3Z7U4Cc The **Servers** page shows the health of each machine your services run on: CPU, memory and disk. The Node.js and Python SDKs report it every 30 seconds from each server, with no extra setup. Open **Servers** in the sidebar, under **Your product**. #### What the page shows - **Three cards on top**: CPU, memory and disk. Each shows the highest number across your servers, so one busy machine is enough to raise it. - **A chart for each**, with the average and the peak. - **Pick one server** (for example `api-2`) to see only its own lines. - Choose the time range and how often the page refreshes at the top. Serverless functions (Vercel, Firebase, AWS Lambda and similar) have no server of their own, so they send no host numbers. #### When to look You don't need to watch this page. Relia does: - On Home, the **Servers** line turns amber (watch) when memory or disk passes 80 %, and red past 90 %. - Relia raises an incident when CPU, memory or disk is high, and links it to the slow requests on that server when they happen together. - Relia also looks ahead: memory that keeps growing hour after hour, or a disk that will be full within 7 days, becomes a warning before it breaks anything. Open Servers when an incident points at a machine, or when the Home line changes colour. A typical pattern: one server's memory climbs from Monday morning, hour after hour, until a restart. > **Tip:** watch [Server running out of memory or disk? See it before it crashes](https://youtu.be/cn-cF38dUgU) (2 min). #### Hide a laptop or test server A developer laptop or test machine that sends data can make your numbers look wrong. Relia already leaves out machines whose environment is `dev`, `development`, `local`, `localhost`, `test` or `testing`. > **Important:** the Node.js SDK reports `development` when `NODE_ENV` is not set, so a real server without `NODE_ENV=production` is left out too. Set it, or switch on **Include development machines** below. To hide any other machine, hide it by name: 1. On the **Servers** page, click **Hosts**. 2. **Which hosts count** lists every machine Relia has seen, with its environment and services. 3. Click the eye next to the machine: **Hide this host**. To count development machines after all, switch on **Include development machines** in the same panel. Only owners and admins can change this. A hidden host keeps sending data, but it is left out of the Servers page, the Map, the Servers line on Home and Relia's host checks. Nothing is deleted; click the eye again to show it. > **Tip:** set the environment on your test machines so they are left out on their own: `NODE_ENV` for Node.js, `RELIA_ENV` (or `ENVIRONMENT` / `APP_ENV`) for Python. See [Environment variables](https://tryrelia.com/docs/environment-variables.md). #### If something's wrong - **No data yet**: host numbers come from the Node.js or Python SDK running on the server. Upgrade to the latest `relia-sdk` and restart the app. - **A real server is missing**: it may report a development environment (on Node.js, `NODE_ENV` not set). Set `NODE_ENV=production` and restart, or switch on **Include development machines** under **Hosts**. - **"Reporter stopped"**: the server stopped sending. Restart the app on that machine. #### Next - [Server running out of memory or disk](https://tryrelia.com/docs/server-memory-disk.md) - [APIs](https://tryrelia.com/docs/apis.md) - [Home](https://tryrelia.com/docs/home.md) ### Uptime monitors and Relia's checks > Add an uptime monitor for your site or API, understand Relia's own page checks, and switch a check off when you don't need it. Section: Each part of Relia · Page: https://tryrelia.com/docs/uptime-and-checks · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/LDWbshEEOvk Relia watches your product from the outside in two ways. **Uptime monitors** check that an address answers. **Relia's checks** open your key pages and the APIs behind them, the way a visitor would. Both live on **Uptime & checks** in the sidebar, under **Your product**. #### Add an uptime monitor 1. Open **Uptime & checks** and click **Add monitor**. 2. Paste the address to watch, for example `https://shop.example.com/products` or `https://api.example.com/health`. 3. Choose **How often to check**: from every 1 minute (the default) to every day. 4. Choose the alerts: e-mail, and on Growth and Pro also Slack, ClickUp or Jira. 5. Click **Add monitor**. The address must be public: Relia does not check private or internal addresses. ##### Check it worked Your monitor gets a card with a bar of recent checks: each block is one check, green means the page answered. The numbers on top add up all your monitors. Open a card for its uptime, total and failed checks, and the recent checks with status code and response time. ##### When is a site "down"? Two failed checks in a row. Then you get one alert when it goes down and one when it recovers, and Relia opens an incident ("site down") that joins the server errors behind it, if any. > **Tip:** watch [Website down? Find out before your customers do](https://youtu.be/Joe6bAUjos8) (2 min). ##### Remove a monitor A monitor has no pause switch. To stop one, click the bin and confirm **Delete monitor**. It is removed with all its check history, for good. | Plan | Uptime monitors | |---|---| | Free | 5 | | Growth | 20 | | Pro | 50 | #### Relia's checks Every 15 minutes, Relia opens your key pages and the read-only API calls those pages make. It picks the pages you said must never break in [Teach Relia](https://tryrelia.com/docs/teach-relia.md), or your busiest page. This catches a broken page before a user does. - Checks only read: `GET` or `HEAD` requests, no forms, no sign-in, nothing is ever changed. - A step fails on a server error, a timeout, a page that isn't HTML, or an answer much slower than usual for it. - A failing check becomes an incident that names the failing step. Checks don't send uptime e-mails. Relia's checks run on **Growth** (20,000 runs a month) and **Pro** (60,000 runs a month), not on Free. The section shows the runs used this month. ##### Set where your app lives If Relia doesn't know your app's address yet, fill in **Your app's address** (a public `https://` address) and click **Save**. Relia then creates the checks. A monitor's address also works. ##### Edit or switch off a check - **Switch it off**: flip the switch on the check's row. It stops running; flip it back on any time. Useful when an uptime monitor already watches the same page. - **Edit it**: change its steps, one request per line, the first line being the page. Only `GET` or `HEAD` are allowed. Relia never changes a check you edited or switched off. Only owners and admins can change checks. #### If something's wrong - **"Down" but the site works for you**: the address may block outside requests, or answer slowly from far away. Open the monitor to see the status code of the failed checks. - **No checks appear**: set **Your app's address**, and check your plan (Growth or Pro). - **A monitor is refused**: the address is private (like `localhost` or a `10.x` address) or already watched. #### Next - [Status page](https://tryrelia.com/docs/status-page.md) - [Promises (SLOs)](https://tryrelia.com/docs/slos.md) - [Notifications](https://tryrelia.com/docs/notifications.md) - [Website down?](https://tryrelia.com/docs/site-down.md) ### Promises (SLOs) and error budgets > Find the promises Relia keeps for your key APIs, understand the error budget with one example, and change a promise. Section: Each part of Relia · Page: https://tryrelia.com/docs/slos · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/0sv0RGmFVRA A promise (also called an SLO, service level objective) says how reliable one API should be, for example "99.9 % of requests succeed over 28 days". Relia sets one per key API from what is normal for it, then warns you when failures pile up faster than the promise allows, before users notice a pattern. Promises are part of the **Growth** and **Pro** plans. #### Where to find them There is no separate Promises page. In the sidebar, under **Relia**, click **What Relia learned**. Your promises are in the card **What Relia protects**. Each row shows: - the API (for example `GET /api/products`) and its service, - who set it: **proposed by Relia** or **set by you**, - the promise as a sentence: "99.9% of requests succeed, and 95% answer in under 0.5 s, over 28 days", - bars for **Succeeding** and **Fast enough** with the budget left, - what Relia based it on ("Based on the last week: … requests, …% failed, p95 … ms"), - **Last 28 days**: click it for a chart of each day. #### Which APIs get a promise Relia picks the APIs you said must never break in [Teach Relia](https://tryrelia.com/docs/teach-relia.md). Without those, it picks your 3 busiest APIs that change data (like `POST /api/orders`). An API needs at least 50 requests a week. The target comes from the API's usual error rate, between 95 % and 99.9 %, and the speed limit (0.5 s, 1 s or 5 s) from its usual response time. > **Tip:** watch [Teach Relia what matters in your product](https://youtu.be/698N_bUto5Y) (2 min). #### The error budget, in one example Your product pages call `GET /api/products` about 100,000 times in 28 days. The promise is 99.9 %: so about 100 of those calls may fail. That room for failures is the **error budget**. - The bar shows how much is left, for example **62 %**. - Only server errors (5xx) use it. A product that is not found (404) doesn't. - The speed promise has its own budget: requests slower than the limit use it. #### When Relia alerts you Relia measures how fast the budget is being used (the "burn rate"): - **Fast burn**: over the last hour and the last 5 minutes, failures use the budget 14.4 times faster than the promise allows. This needs you now. - **Slow burn**: over 6 hours and 30 minutes, 6 times faster. Worth watching. - **Budget low**: less than 10 % of the 28-day budget is left. Each of these needs at least 3 failed requests. The incident joins the API's own error or slowness finding, so you get one story, not two. #### Change a promise Only owners and admins can change a promise; everyone else sees it read-only. 1. In **What Relia protects**, pick a new value in the sentence: the share that must succeed (for example 99.5 % instead of 99.9 %), or the speed limit (0.5 s, 1 s, 5 s or no limit). 2. It saves at once. The row now says **set by you**, and Relia won't propose it again. With 99.5 % in the example above, the room grows from about 100 to about 500 failures. To stop protecting an API, switch its row off. **Propose again** asks Relia to look again at your APIs now; promises you set are kept. Relia adds and adjusts promises on its own by default. You can see each change under **Relia did** on Home, undo it, or ask Relia to ask you first. See [What Relia did](https://tryrelia.com/docs/what-relia-did.md). #### Next - [Teach Relia what matters](https://tryrelia.com/docs/teach-relia.md) - [What Relia did, and undo](https://tryrelia.com/docs/what-relia-did.md) - [Dashboards](https://tryrelia.com/docs/dashboards.md) - [Uptime and checks](https://tryrelia.com/docs/uptime-and-checks.md) ### Create a public status page > Publish a status page your customers can check, post incidents and updates, and on Growth or Pro add your logo and your own domain. Section: Each part of Relia · Page: https://tryrelia.com/docs/status-page · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/82-Mi35wfrE A status page is a public page where your customers can check that your product is working. Relia builds it from the monitors and checks it already runs, and never shows anything internal: no servers, routes, error messages or numbers from inside your app. #### Before you start - You are an owner or admin of the project. Others can see the setup but not change it. - At least one uptime monitor or Relia check exists. See [Uptime and checks](https://tryrelia.com/docs/uptime-and-checks.md). #### Steps 1. Open **Status page** in the sidebar. 2. **Name your page**: usually your product's name, for example `Northwind status`. 3. **Choose what customers see**: add one part per thing customers recognise (Website, Checkout, Login, API) and pick the monitors or checks behind each. A part is up when the things that check it pass. Group parts into sections if you like, such as Website and Help. 4. **Publish**: switch on **Visible to everyone with the link**, then click **Save and publish**. Every part needs a name and at least one monitor or check, or Relia names the part that is missing one. #### Check it worked The page is live at its own link (`/status/` on `app.tryrelia.com`). Customers see each part's state, its last 90 days as daily bars (with a 7, 30 or 90-day view), and your posts. A monitor that failed once shows the part as having problems; twice in a row, as down. The setup page also shows a live preview, even before you publish. #### Post an incident or an update In **Incidents and updates (optional)**: 1. Write a title (for example `Payments are slow`) and what customers should know. 2. Tick the parts it affects and click **Publish incident**. 3. When you learn more, pick a new status (investigating, identified, monitoring, resolved) and click **Post update**. Post **resolved** when it's fixed. Relia also posts outages it sees from outside (a monitor or check failing), in customer words like "Checkout is unavailable", and marks them resolved when the part recovers. This is the **Post outages automatically** switch in step 3, on by default. To have Relia ask you first, switch it off or set **Status page posts** to **Ask me first** in **Settings → Advanced → Autonomy** ([What Relia did](https://tryrelia.com/docs/what-relia-did.md)). > **Tip:** watch [Website down? Find out before your customers do](https://youtu.be/Joe6bAUjos8) (2 min). #### Make it yours (Growth and Pro) ##### Add a logo In step 1, click **Add a logo**: PNG, JPEG or WebP, up to 200 KB. ##### Use your own address 1. Under **Your own address (optional)**, type the address, for example `status.yourproduct.com`, and click **Add**. 2. At your domain provider, add the DNS record Relia shows: a CNAME pointing to `userstatus.tryrelia.com`. 3. Click **Verify now**. Once verified, the certificate is set up for you; this can take a minute. Use a subdomain such as `status.`. A bare domain can't take a CNAME; there, an ALIAS record to the same target works if your provider offers one. On Cloudflare, set the record to **DNS only** (grey cloud). Relia re-checks the DNS every day; if it stops pointing to Relia, the page keeps answering for a week, then the address is detached. The Relia link keeps working either way. #### Notify your tools (optional) - **Atom feed**: every page has one, linked at the bottom of the public page. Feed readers and many tools can follow it. - **Webhook** (Growth and Pro): Relia sends a signed event to one URL when a part goes down or recovers, a post changes, or a postmortem is published. Connect it to Zapier, Make or your own backend. The signing secret is shown once; **Send a test event** checks it works. Relia keeps no mailing list of your customers. #### If something's wrong - **Verify fails**: the CNAME isn't visible yet (DNS can take a while), or Cloudflare's proxy hides it. Set it to DNS only and click **Verify now** again. - **A part shows down but your site works**: open the monitor behind it on **Uptime & checks** to see the failed checks. - **Your own address isn't offered**: it needs the Growth or Pro plan. #### Next - [Uptime and checks](https://tryrelia.com/docs/uptime-and-checks.md) - [Write a postmortem](https://tryrelia.com/docs/postmortems.md) - [Plans and billing](https://tryrelia.com/docs/plans-and-billing.md) ### Dashboards > Use the dashboards Relia makes for you, build your own without queries, and share them on an office screen or as PNG and CSV. Section: Each part of Relia · Page: https://tryrelia.com/docs/dashboards · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/0m3zt2P2XM0 Relia makes a dashboard for every service and every page that matters, from day one. You can also make your own by picking charts from lists: there is no query language, so a chart can't break or show another project's data. Click **Dashboards** in the sidebar. There are three tabs: - **Yours**: dashboards you made, including those made in Ask Relia. - **Team**: dashboards others made and shared. - **Relia's**: one per service and per page that matters, the ones most at risk first (a promise running out of budget, recent incidents, failing now), then the ones that changed (deployed in the last 7 days), then your busiest. #### Make your own dashboard 1. Click **New dashboard**. 2. Start **blank**, from a **template**, or from a copy of Relia's dashboard for a service. Templates: API health, Servers, Database, Page speed, Traffic, AI agents, Changes and incidents, Uptime and promises, Checkout health and Launch day. 3. Click **Edit** (a blank dashboard opens in Edit already) and give it a name, for example `Catalog health`. 4. Click **Add a panel** and pick its kind, then what to show. The preview is the real panel. 5. Click **Save**. On any of Relia's service dashboards, **Copy and edit** does steps 1 and 2 for you. ##### Kinds of panel | Kind | What it shows | |---|---| | Chart | Lines, areas, bars or a pie (pie only for numbers that add up, like requests) | | Big number | One value and how it changed since the period before | | Top list | The slowest, busiest or most failing APIs, pages, queries… | | Status | Your uptime monitors, Relia's checks, or the error budget left on each promise | | Incidents | What is open now, for every service or only the ones you tick | | Note | Your own words, for example what to check first when something breaks | For a chart you choose **What** (the number), **For** (one service, API, server, dependency, monitor or promise, or everything), **Split by**, and **Show as**. You can chart APIs, the database, servers, dependencies, page speed, uptime, promises, visitors, page views, log errors and warnings, your AI features, funnels, incidents and deploys. In **Edit**, each panel can be sized **S / M / L**, changed, duplicated, removed or dragged to a new place. #### Time and filters - The **time bar** sets one period for every chart (15 minutes to 30 days, or chosen dates inside your plan's history), can compare with the period before, and can refresh every minute or every 5 minutes. - **Show only** narrows every chart that can be narrowed: by service, environment, country or device (for example only mobile). A chart that can't be narrowed says so. - These change only your view. **Make this the default** saves them for everyone. Dashed grey lines on a chart are deploys; red and amber lines are incidents. When a one-line chart moved after one, Relia says by how much underneath. #### Ask Relia to change it Type what you want in the box above the panels, for example "add p95 of the checkout API" or "make it 7 days". Relia shows the changes; nothing is kept until you click **Save**. Each request counts as one Ask Relia answer. > **Tip:** watch [Ask your production data questions in plain English (Ask Relia)](https://youtu.be/z3LCOFL7T_U) (2 min). #### Share it - Dashboards are for the whole team unless you tick **Only I can see this dashboard** in the editor. - **Star** a dashboard to put it first in your list and on Home. Stars are yours alone. - **TV** shows the dashboard full screen for an office screen, refreshed every minute. **Rotate starred** goes through your starred dashboards, one a minute. - Under each panel, **Download** offers **PNG** (a chart as a picture) and **CSV** (its numbers, for a spreadsheet). TV mode, PNG and CSV are part of the Growth and Pro plans. #### Who can do what Members can make and change dashboards; viewers can look. A dashboard can be removed by whoever made it, or by an owner or admin. | Plan | Your dashboards | Panels per dashboard | |---|---|---| | Free | 2 | 6 | | Growth | 10 | 20 | | Pro | 30 | 30 | Dashboards made in Ask Relia count too. #### If something's wrong - **A panel says its data is gone**: it shows something that no longer exists (a removed funnel or monitor, or a service Relia hasn't seen for 30 days, often after a rename). Click **Edit** to pick something else, or **Remove**, then **Save**. - **Someone else saved while you edited**: Relia asks you to reload instead of overwriting their change. #### Next - [Ask Relia](https://tryrelia.com/docs/ask-relia.md) - [Promises (SLOs)](https://tryrelia.com/docs/slos.md) - [Plans and billing](https://tryrelia.com/docs/plans-and-billing.md) ### AI in your product > Read the AI in your product pages: how your AI features are doing, what they cost, which runs and tools fail, and your MCP server's tool calls. Section: Each part of Relia · Page: https://tryrelia.com/docs/ai-in-your-product · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/szMNhbJQauU **AI in your product** watches the AI features inside your product: the calls your code makes to model providers, the tools your AI uses while it works, and the tools your own MCP server offers to AI assistants. It is not about Claude Code or Cursor connecting to Relia; those are on your Profile ([Tokens and connected tools](https://tryrelia.com/docs/tokens-and-connected-tools.md)). #### What gets recorded With the usual setup (`npx relia-sdk@latest init`, or `python -m relia`), and nothing else to add: - **Model calls**: each call to OpenAI, Anthropic, Google Gemini, OpenRouter, Groq, Mistral, DeepSeek, Together, xAI, Perplexity, Fireworks or Cohere becomes a run with the model, tokens, estimated cost, how long it took and whether it failed. Streamed answers included. In Node.js that covers the `openai` and `@anthropic-ai/sdk` packages, the Vercel AI SDK and plain `fetch`; in Python the `openai` and `anthropic` packages and anything using `httpx` or `requests`; in edge functions, calls made inside `withRelia`. - **Tool calls**: when your AI calls its own tools (like `search_orders`), each one is a step of the run, with its time and whether it failed. - **Your MCP server**: if your product offers tools to AI assistants with the official MCP SDK (Node.js or Python), every tool call is recorded: the tool, which assistant called it, how long it took and whether it failed. What the assistant asked and what the tool answered are never recorded. Model calls and MCP tool calls need `relia-sdk` 0.8 or later on npm, or 0.6 or later on PyPI. > **Tip:** watch [Monitor OpenAI, Anthropic and Gemini calls in your app with no code](https://youtu.be/xcQ2aAHnrRM) (2 min). #### The four pages Open **AI in your product** in the sidebar, under **Your product**. ##### Agents At the top: how many AI features you run, how often they ran, and what they cost. **Fleet Success Rate** is the share of runs that worked; the target is 96 % or more. Below, each AI feature is one row with its runs, speed, success rate and tokens, marked **Healthy**, **Degraded** or **Failing**. Open one for its trend and which providers and models it uses. ##### Runs Every time the AI answered: the question, how long it took, the tokens and what it cost. Choose **Errors Only** to see what failed, for example a provider answering "rate limited". Open a run to see each model call and tool call in order. ##### Tool calls The tools your AI uses: how often, how fast, how often they fail. Below it, **Your MCP server** lists each tool your server offers with calls, failures and speed, and which AI assistants called it. Click a tool to see its latest calls. If you have no MCP server, this part is empty. ##### Agent issues Relia flags AI that loops, retries a failing step, runs slow, or uses far more tokens than usual. #### When Relia raises an incident Relia reads every run of the project, including runs from background jobs and scripts. It raises an incident when runs fail or get slow, when spending jumps (at least $1 and 3 times the usual for the same length of time), or when an MCP tool starts failing or slowing down. A run inside a failing request joins that request's incident, so you see one story. > **Tip:** watch [AI feature failing or costing too much? Monitor LLM calls and MCP tools](https://youtu.be/OCDIWdXLIQs) (2 min). #### Good to know - Costs are estimates from public list prices. A model Relia doesn't know shows no cost rather than a guess. - Prompts and answers of model calls are kept with e-mail addresses, phone numbers and card numbers masked. - Each AI run counts 5 units of your plan's monthly pool. MCP tool calls cost no extra units. - Turn off model-call capture with `RELIA_AI_CAPTURE=0`, and MCP recording with `RELIA_DISABLE_INSTRUMENTATIONS=mcp`. #### Next - [Monitor AI calls with no code](https://tryrelia.com/docs/ai-calls-setup.md) - [AI feature failing or costing too much?](https://tryrelia.com/docs/ai-feature-failing.md) - [Privacy](https://tryrelia.com/docs/privacy.md) ### What Relia did on its own, and how to undo it > See every change Relia made by itself, undo the ones you don't want, and choose what it may do on its own, ask first, or never do. Section: Settings and safety · Page: https://tryrelia.com/docs/what-relia-did · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/PZuW0boeoAU Relia does some upkeep on its own so you don't have to: learning what is normal for your app, keeping its page checks and promises up to date. Every change is listed with why and when, and each one can be undone. You decide how far this goes. Relia never changes your code, and never rolls back or restarts anything without your approval. #### See what Relia did On **Home**, scroll down to **Relia did**. Each row says what Relia changed (for example, a promise proposed for one of your APIs, or a check added for an important page), why, and when. The daily summary e-mail lists these changes too. #### Undo a change Click **Undo** on the row. Only owners and admins see the button. Nothing is deleted when you undo: | What Relia did | What Undo does | |---|---| | Learned that a pattern is normal (for example a nightly job) | Forgets it, so alerts work as before | | Created or changed a check | Switches the check off; Relia won't make it again | | Proposed or changed a promise | Switches it off, or puts the previous promise back | | Lowered a kind of alert you kept marking wrong | Puts it back; Relia leaves it alone for 30 days | | Added an uptime monitor | Switches the monitor off | | Posted an outage on your status page | Takes the post down | #### Choose what Relia may do Open **Settings**, then the **Advanced** tab. **Autonomy** opens first: **What Relia may do on its own**. Each kind of action has three choices: - **Do it, tell me**: Relia acts and lists it under **Relia did**, with an Undo. - **Ask me first**: nothing happens until you say yes. - **Never**: Relia leaves it alone. A choice saves as soon as you click it. Only owners and admins can change these. | Kind of action | What it covers | Default | |---|---|---| | Learn what is normal | Treat a learned pattern (polling, a nightly job, a route that answers 4xx by design) as normal. It only softens one kind of alarm on one path; a server error is never hidden. | Do it, tell me | | Relia's checks | Create and adjust the read-only checks that open your important pages and the APIs they call | Do it, tell me | | Promises (SLOs) | Propose promises for your important APIs and adjust them as the normal changes. A promise you edited is never touched. | Do it, tell me | | Lower noisy kinds | When you keep marking one kind of finding wrong or noise, raise it to "needs you" less often. Never hidden. | Do it, tell me | | Uptime monitors | Add an uptime monitor for a public address your services answer on | Ask me first | | Status page posts | Publish an outage visible from outside on your status page, in public words | Ask me first (Do it, tell me while your published status page has **Post outages automatically** on, which it is by default) | Checks, promises and monitor suggestions are part of the Growth and Pro plans. > **Tip:** watch [Relia asks: one question a day to learn your product](https://youtu.be/XspzZNUfUv8) (2 min). #### When Relia asks first For a kind set to **Ask me first**, the question shows up on Home as a **Relia asks** card, for example asking whether to add an uptime monitor for a public address your service answers on. Click the answer you want (for example **Yes, add it**). Your yes is listed under **Relia did** like any other change, so it can be undone too. Status page posts are urgent, so Relia asks about them right away. Other questions come at most one a day. #### What always needs you Rollbacks and restarts are never on autopilot: they always need an owner or admin to approve them, signed in to Relia. Changes to your code are yours: Relia suggests fixes, it doesn't make them. Every change Relia makes is also in the project's audit log, with Relia as the actor. #### Next - [Promises (SLOs)](https://tryrelia.com/docs/slos.md) - [Uptime and checks](https://tryrelia.com/docs/uptime-and-checks.md) - [Relia asks](https://tryrelia.com/docs/relia-asks.md) - [Teach Relia when an alert is wrong](https://tryrelia.com/docs/feedback.md) ### Control what Relia collects (SDK settings) > Pause Relia, record fewer sessions, ignore pages and routes, and leave out button text, page speed or replays, without a new deploy. Section: Settings and safety · Page: https://tryrelia.com/docs/sdk-settings · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/eTS5T0wgMdQ SDK settings let you change what Relia's SDKs collect from your apps, from the Relia app, with no code change and no new deploy. They can only collect **less** than your code allows, never more. They never delete anything already stored, and you can switch any of them back. #### Before you start - You are an owner or admin of the project. Others can see the settings but not change them. #### Open the settings Click **Settings** in the sidebar, then the **Advanced** tab, then **SDK settings**. Changes reach your browser, Node.js and Python apps within about 10 minutes. #### The settings | Setting | What it does | Default | |---|---|---| | **Monitoring** | Off pauses Relia for the whole project: every browser, Node.js and Python app of this project stops sending. Nothing already stored is touched. Switch it back on to carry on. | On | | **Button and link text** | Off records clicks without the words on the button or link. | On (text is still only recorded if your code sets `captureText: true`; Relia's setup writes `false`) | | **Page speed** | Off sends no web vitals from the browser. | On | | **Screen replays** | Off records no replays, even where your app's code turned them on. | On (replays still only happen if your code asks for them) | | **Sessions recorded** | The share of browser sessions kept, 1 to 100 %. At 50, about half. | 100 | | **Pages and routes to ignore** | Pages (browser) and incoming routes (server) that are never recorded. One per line, up to 30. | none | Switches save as soon as you flip them. For **Sessions recorded** and **Pages and routes to ignore**, click **Save**; you'll see "Saved. SDKs pick it up within 10 minutes." ##### Sessions recorded Which sessions are kept is decided per session, so a visitor's reload stays in or out together. Errors in skipped sessions are not seen, so stay at 100 unless you need to record less. ##### Pages and routes to ignore Write paths, each starting with `/`: ```text /health /admin/* /orders/*/receipt ``` - `/admin/*` ignores everything below `/admin`. - `*` in the middle matches any one part of the path. - No spaces, no query strings (`?…`). #### Which apps follow which setting | App | Follows | |---|---| | Web app (browser SDK) | Every setting | | Node.js and Python servers | **Monitoring** and **Pages and routes to ignore** only | | PHP / Laravel and OpenTelemetry apps | None of these settings | An app checks for new settings about every 10 minutes. To stop the server fetch entirely in an app, set `RELIA_REMOTE_SETTINGS=0`. > **Tip:** watch [Privacy in Relia: what is recorded and what never is](https://youtu.be/G-WlncnUWeY) (2 min). #### Check it worked Wait about 10 minutes, then use your app. With **Monitoring** off, nothing new arrives on the project's **Setup** tab. With a page ignored, it stops showing new visits on **Visitors** and **Sessions**; with a route ignored, new requests to it stop appearing on **Requests**. #### If something's wrong - **A change didn't apply after 10 minutes**: the app may run an older SDK. Update to the latest `relia-sdk` and redeploy once. - **A PHP app still sends**: PHP doesn't read these settings. Remove or change its setup in the app. - **"Not a path"**: each line must start with `/` and have no spaces or `?`. #### Next - [Privacy](https://tryrelia.com/docs/privacy.md) - [Plans and limits](https://tryrelia.com/docs/plans-and-limits.md) - [Environment variables](https://tryrelia.com/docs/environment-variables.md) ### Privacy: what Relia records and what it never does > Know what Relia stores about your app and your visitors, what it never records, how long data is kept, and how to export, erase or clean it up. Section: Settings and safety · Page: https://tryrelia.com/docs/privacy · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/G-WlncnUWeY Relia records enough to tell you what broke and who it hit, and no more. This page lists what is stored, what never is, and the controls you have. #### What Relia stores - **Requests and errors**: each request to your server (endpoint, status, timing), errors with their stack traces, and warning and error log lines. - **Database query shapes**: statements with the values replaced by `?`. The SDK masks them on your server, before anything is sent. - **Server metrics**: CPU, memory and disk. - **What people do in your app**: pages, clicks, form submits, errors and page speed. - **People you identify** with `Relia.identify`: the id, and only the e-mail, name, plan and a few plain fields you choose to send. - **AI calls in your product**: model, tokens, timing and cost, and prompts and answers with e-mail addresses, phone numbers and card numbers masked. Data is kept for your plan's history: 7 days on Free, 30 on Growth, 90 on Pro. #### What Relia never records - **What people type.** For a text box Relia only gets how many characters were typed, never the text. - **Passwords, tokens and card numbers.** They are dropped on the device, and again on Relia's servers. - **Full IP addresses of visitors.** For visits in your app, Relia looks up the country and city first, then drops the last part of the address. The full address is never kept. (Requests to your server keep the client address your server reports, which is how Relia spots login abuse from one address.) - **Your MCP server's arguments and answers.** Only the tool, the assistant, the time and whether it failed. - **Screen recordings, unless you turn them on.** Relia's setup leaves session replays off (`replay: false`). If you turn them on, everything typed into a form is masked. What the SDKs collect is used only to watch your project. Relia never trains AI models on it. #### What the AI sees Incident write-ups, Ask Relia and fix plans see counts, routes and errors. They never see people's identities: who was affected is given as numbers and plan names ("3 customers on Pro"). Identities also never appear in alert e-mails or Slack. Lines of your source code are sent only if an owner or admin turns on **Source code in AI fix plans** in the project's **Notifications** settings. #### Your controls ##### Leave out button and link text Relia's setup (`npx relia-sdk@latest init`, or your AI assistant) writes `captureText: false`, so clicks are recorded without the words on the button or link. If your app's code sets `captureText: true`, you can still drop the text without a deploy: open **Settings → Advanced → SDK settings** and switch **Button and link text** off. Clicks are still recorded, without the words. See [SDK settings](https://tryrelia.com/docs/sdk-settings.md). > **Tip:** watch [Control what Relia collects: sampling, ignored pages, kill switch](https://youtu.be/eTS5T0wgMdQ) (2 min). ##### One person's data On **People**, open a person. Owners and admins can: - **Export data**: download what Relia has about that person. - **Erase identity**: remove their id, e-mail and details from their sessions. The visits stay, without a name. Every look at a person's profile and every export is written to the audit log. ##### Clean up early Open **Settings → Advanced → Data cleanup**, set how many days to keep for each kind of data (traces, sessions, agent runs, session replays), and scan. Relia proposes a plan with what would be deleted. **Nothing is deleted until an owner or admin approves the plan.** You can also reject it. ##### Delete a project Deleting a project (**Settings → Advanced → Danger zone**) removes everything it owns. The audit trail is kept. #### The audit log **Settings → Advanced → Audit log** shows every change in the project: who made it, when, from where, and what changed (secrets masked). Changes Relia made on its own are listed with Relia as the actor. Entries are kept for a year and can't be edited or deleted. The audit log is on Growth and Pro, for owners and admins. Your own sign-ins and account changes are on your Profile under **Recent account activity**. #### Next - [SDK settings](https://tryrelia.com/docs/sdk-settings.md) - [Tokens and connected tools](https://tryrelia.com/docs/tokens-and-connected-tools.md) - [Identify your users](https://tryrelia.com/docs/identify-users.md) - [Team and roles](https://tryrelia.com/docs/team-and-roles.md) ### Manage AI assistant tokens and connected tools > Check which AI tools, tokens and machines can reach your Relia account, and disconnect or revoke the ones you don't use. Section: Settings and safety · Page: https://tryrelia.com/docs/tokens-and-connected-tools · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/fDJey2806Ug AI tools (Claude Code, Cursor, Codex…), scripts and the `relia-sdk` CLI reach Relia as you. This page shows where to see them all and how to cut off the ones you don't use. A good habit: check once a month. #### Open your Profile Click your name at the bottom of the sidebar. Two cards matter here: **Use Relia in your AI assistants** and **CLI tokens**. #### Connected tools (sign-ins) When you set up your AI tools with: ```bash npx -y relia-sdk@latest mcp install ``` each tool asks you to sign in to Relia the first time. No token is copied anywhere. Every tool you signed in from is listed under **Connected tools**, with: - its name, - the projects it can see (**all projects**, or how many you chose), - when it was last used. To remove one, click **Disconnect**. There is no confirm step: it is removed at once, and that tool loses its access. If you disconnect every tool, the **Connected tools** list goes away. Need a tool back? Set it up again and sign in. > **Tip:** watch [Connect Claude Code, Cursor and Codex to Relia (MCP setup)](https://youtu.be/fpGlCkJzzKA) (2 min). #### Tokens for CI and scripts For a script, CI, or a tool that can't sign in, open **Use a token (CI and scripts)** on the same card. - **Create a token**: give it a name (for example `CI`) and click **Create a token**. Copy it right away: Relia shows it only once. Use it with `--token` or as `RELIA_MCP_TOKEN`. - Your tokens are listed under the form: each shows its name, its last characters and when it was last used. - **Revoke**: click it next to a token you don't recognise or no longer need. Again, it is gone right away. Keep tokens private, like a password. Relia stores only a fingerprint of each token, never the token itself. Projects created before account-wide tokens may also have older one-project tokens. Find and revoke them in the project's **Settings → Advanced → Integrations**. #### CLI tokens **CLI tokens** are the machines where you ran `npx relia-sdk@latest init`, plus the upload-only tokens it made for source maps (`RELIA_TOKEN`). Each shows the machine, when it was last used and when it expires. - A setup token can only set up projects and services. It can't read your data. - An upload-only token can only upload source maps for one project. - Click **Revoke** next to any you don't recognise. #### When tokens expire on their own | Kind | Expires after | |---|---| | CLI setup token | 30 days without use | | Upload-only token for source maps | 180 days without use | | AI assistant token (CI and scripts) | 90 days without use | | AI tool sign-in | 90 days without use | Each use pushes the expiry forward. #### What an AI tool can do with access It reads: what needs you, incidents, fix plans, dashboards, requests, logs and more. Anything that writes (marking a fix, acknowledging an alert, recording a deploy, creating a project) needs your confirmation first and is written to the project's audit log. It can't change settings, delete data or see passwords. #### If you think someone else has access 1. Disconnect every tool and revoke every token you don't recognise. 2. On your Profile, click **Sign out everywhere**. It ends every browser session and every CLI token. 3. Change your password if you think it leaked. A password reset also signs you out everywhere. Your Profile's **Recent account activity** lists sign-ins, including failed attempts. #### Next - [Connect your AI assistant](https://tryrelia.com/docs/connect-ai-assistant.md) - [AI assistant can't reach Relia?](https://tryrelia.com/docs/mcp-connection.md) - [MCP tools](https://tryrelia.com/docs/mcp-tools.md) - [Privacy](https://tryrelia.com/docs/privacy.md) ### Relia shows no data > Find out why your app runs but Relia shows nothing, and get your first requests and visits to arrive. Section: When something doesn't work · Page: https://tryrelia.com/docs/no-data · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/ADtwub0yrj8 Your app runs, but Relia stays empty. Relia does not show an error for this: data sent with another project's id lands in that project, and data sent with a key from another project is refused without a message in your app. Work through the checks below in order. Most fixes take a minute. #### What you'll see Open your project in Relia, then the **Setup** tab. The card **Is Relia receiving everything?** shows one row per part of your app: - **Requests from your server**: requests per service from the last 7 days. - **Visits to your web app**: browser sessions from the last 7 days. - **Source maps (readable browser errors)**, and the optional rows **Who your users are** and **AI agent runs**. Each row says **Not yet**, **Arriving** (data in the last hour), **Received**, or **Optional**. When nothing has arrived, the card's title says **Waiting for data**. Each missing row shows the one step left. > **Tip:** your AI assistant can run the same check. Ask it "Is Relia receiving everything?" (it calls `relia_check_setup`). See [Connect your AI assistant](https://tryrelia.com/docs/connect-ai-assistant.md). #### Find the cause Try these in order. After each one, use your app (open a page or call an API), wait a minute, and look at the Setup tab again. It updates by itself. 1. **Did the app restart after setup?** The SDK only starts with the process. Stop the app and start it again. 2. **Is there traffic?** Relia shows requests and visits, not idle servers. Open a page or call one of your endpoints. 3. **Is it the right project?** The project id in your app must be your project's id (shown on your project page under **Setup Guide & SDK**). Look at `RELIA_PROJECT_ID` in `.env` or `.env.local`, or the `projectId` / `project_id` in `relia.tracing.js` or `src/relia.ts`. An id from another project sends data to that project. 4. **Is it the right key?** A project key (`RELIA_KEY`, starts with `relia_live_`) from another project is refused. A missing key is still accepted. The quickest fix for 3 and 4: run the setup again and pick the right project, or copy the id and key from **Setup Guide & SDK**. 5. **Is Relia loaded first? (Node.js)** The generated `relia.tracing.js` (or `instrumentation.ts` in Next.js) must run before your framework is loaded. If it is required after Express, Fastify or similar, requests are not seen. 6. **Is the deployed app set up too?** Your `.env` and `.env.local` files are usually not deployed. Add the same `RELIA_*` values to your host's environment variables (Vercel, Render, Railway, Forge…), then deploy again. 7. **Can your server reach Relia?** A firewall or company network that blocks outgoing traffic stops everything. Your server must be able to reach Relia over HTTPS. 8. **Is monitoring switched off?** In the project's **Settings**, **Advanced**, **SDK settings**, the **Monitoring** switch pauses every SDK of the project within 10 minutes. **Sessions recorded** below 100 % keeps only part of the visits. > **Tip:** watch [Control what Relia collects: sampling, ignored pages, kill switch](https://youtu.be/eTS5T0wgMdQ) (2 min). #### Less common causes - **Old SDK on Windows or Node.js 17 and later.** Versions of `relia-sdk` before 0.5.1 could fail without a message when the address was `localhost`. Update the package: `npm install relia-sdk@latest`. - **Your app already uses OpenTelemetry.** Relia adds itself to your existing setup when it can. When it can't, it prints the endpoint and the `relia.project_id` attribute to add to your own exporter when the app starts. Look for a line starting with `[relia]` in your app's output. - **Over the monthly limit.** Relia never stops at the limit: new data is sampled (about 1 in 10 kept, errors and slow requests always kept). You still see data, just less of it. See [Plans and limits](https://tryrelia.com/docs/plans-and-limits.md). #### Check it worked The **Setup** tab shows **Arriving** for the part you fixed. When every part your app has is in, the title says **All set**. The first requests usually show within a minute. #### Still empty? Ask for help from **Help & support** in the app's menu. Include the service name, the language and framework, and what the setup printed. See [Get help](https://tryrelia.com/docs/getting-help.md). #### Next - [Set up Relia with your AI assistant](https://tryrelia.com/docs/setup-with-ai-assistant.md) - [Control what Relia collects](https://tryrelia.com/docs/sdk-settings.md) - [Environment variables](https://tryrelia.com/docs/environment-variables.md) - [Browser errors show minified code](https://tryrelia.com/docs/source-maps.md) ### Browser errors show minified code > Upload your build's source maps so browser errors in Relia point at your own file, line and function instead of a minified bundle. Section: When something doesn't work · Page: https://tryrelia.com/docs/source-maps · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/ArLJuvippU8 A production build squeezes your code into files like `index-a8f3.js`. Without source maps, a browser error in Relia points there. With source maps, Relia shows the original file, line and function, with the code around it. Your maps are uploaded to Relia and removed from the build output, so your source code is never published. #### What you'll see - In a session's **Console** tab, the stack points at a minified file. Under it Relia says: **Minified code (…). Upload source maps to see your file and line**. - On the project's **Setup** tab, the row **Source maps (readable browser errors)** says **None uploaded yet. They upload on your next build.** - In your host's build log, the build still succeeds, with one yellow line: `[relia] source maps were not uploaded: …`. #### Find the cause `npx relia-sdk@latest init` already wires the upload when it sets up a web app: - **Vite apps** get the `reliaSourcemaps` plugin in `vite.config`. - **Other bundlers** get `&& relia sourcemaps upload --project-id --build-step` added to the `build` script. With `--build-step` a failed upload never breaks your build, and the maps are still removed. - It writes an upload token, `RELIA_TOKEN`, to `.env.local` and makes sure `.gitignore` covers `.env.local`. This token can only upload source maps for this one project. The usual cause: your host (Vercel, Netlify, Render, CI) builds without your `.env.local`, so it has no token. The build log says `no Relia token`. #### Fix it 1. In your app's folder, open `.env.local` and copy the value of `RELIA_TOKEN`. Lost it? Write it again: ```bash npx relia-sdk@latest token ``` It finds the project id in the folder (or pass `--project-id `), asks you to sign in if needed, and writes `RELIA_TOKEN` to `.env.local`. A new token replaces your previous upload token for that project. 2. In your host's environment variables, add `RELIA_TOKEN` with that value. 3. Build and deploy again. The build log now reports the uploaded maps and that they were removed from the output. > **Note:** Next.js is not wired by `init`. Turn on `productionBrowserSourceMaps` in `next.config`, and run the upload after `next build` (see below). #### Set it up by hand **Vite**, in `vite.config.ts`: ```ts import { reliaSourcemaps } from "relia-sdk/vite" export default { plugins: [reliaSourcemaps({ projectId: "YOUR_PROJECT_ID" })] } ``` The plugin turns on hidden source maps when your config doesn't set `build.sourcemap`, uploads after the build, then deletes the `.map` files. Options: `projectId`, `release`, `keepMaps` (keep the `.map` files in the output; default `false`), `failOnError` (fail the build when the upload fails; default `false`) and `disabled`. If your config sets `build.sourcemap: false`, there is nothing to upload: remove it or set it to `"hidden"`. **Any build**, after the build step: ```bash npx relia-sdk@latest sourcemaps upload ./dist --project-id YOUR_PROJECT_ID ``` Uploading needs `RELIA_TOKEN` (from the environment, or from `.env.local` / `.env` in the folder) or the login saved by `npx relia-sdk@latest init`. Maps are matched by the bundle's file name, so no release setup is needed. All flags are in the [CLI reference](https://tryrelia.com/docs/cli.md#sourcemaps-upload). #### Check the fix worked - The **Setup** tab row says **Browser errors point at your own files.** - The next browser error in a session's **Console** tab shows your file and line (for example `src/main.ts:4 in handlePay`) with the line highlighted. A toggle still shows the minified stack. Errors that happened before the upload stay minified; new ones are readable. > **Tip:** watch [Fix JavaScript errors in production with readable stack traces](https://youtu.be/DrD9OWbQ_nQ) (2 min). #### If something's wrong - **`no project id`**: pass `--project-id ` or set `RELIA_PROJECT_ID`. - **`no .map files in ./dist`**: your build does not write source maps. Turn them on in your bundler, or check the folder name (`dist`, `build`…). - **401 or "token expired"**: run `npx relia-sdk@latest token` again and update `RELIA_TOKEN` on your host. #### Next - [Monitor a web app](https://tryrelia.com/docs/web-app-setup.md) - [Fix JavaScript errors](https://tryrelia.com/docs/javascript-errors.md) - [CLI reference](https://tryrelia.com/docs/cli.md) - [Environment variables](https://tryrelia.com/docs/environment-variables.md) ### Your AI assistant can't reach Relia > Fix an AI assistant (Claude Code, Cursor, Codex, VS Code…) that can't read Relia, in three checks. Section: When something doesn't work · Page: https://tryrelia.com/docs/mcp-connection · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/c55QHvtNiSk You ask your AI assistant about your app and it answers with an error such as **Sign in with Relia**, or it doesn't list Relia at all. Try these three fixes in order. #### What you'll see - An error from the Relia tool: "Sign in with Relia, or add a Relia MCP token…", or a 401. - In Cursor, Relia's entry says **Needs login**. - Or the assistant doesn't know about Relia: no `relia_*` tools. #### Fix 1: sign in again Sign-ins and tokens expire after **90 days without use**. If the error mentions signing in, this is your fix. - **Claude Code:** type `/mcp`, pick **relia**, and choose **Authenticate**. - **Cursor:** click **Needs login** next to Relia in the MCP settings. - **Other tools:** use the tool's own sign-in or reconnect action for Relia. A browser opens on Relia. Read what the tool is asking for, choose all projects or only some, and click **Allow**. You are sent back to your tool. #### Fix 2: restart the tool After an install, quit the tool fully and open it again. Tools read their MCP settings when they start. The install says so at the end: **Restart those tools.** #### Fix 3: check what's set up ```bash npx relia-sdk@latest mcp status ``` Each tool shows one of: - **set up**: Relia is added. - **not installed**: the tool isn't on this computer. - **installed, Relia not added**: run the install again. ```bash npx -y relia-sdk@latest mcp install ``` It adds Relia to every AI tool it finds and keeps your other settings. Only some tools? Add `--only`, for example `--only cursor,codex`. Then restart the tool and sign in. No Node.js on this computer? Use Python instead: `uvx --from relia-sdk@latest relia mcp install`. > **Tip:** watch [Connect Claude Code, Cursor and Codex to Relia (MCP setup)](https://youtu.be/fpGlCkJzzKA) (2 min). #### Other problems - **Claude Desktop or claude.ai:** the install marks Claude Desktop as **one step left**: you add Relia by hand. Open **Settings → Connectors → Add custom connector** and paste `https://devreliaapi.tryrelia.com/mcp`. - **"Relia refused the token"** (token mode): the token was revoked or expired. Create a new one on your **Profile** under **Use Relia in your AI assistants**, then run `npx -y relia-sdk@latest mcp install --token `. - **"That isn't a Relia MCP token"**: MCP tokens start with `relia_mcp_`. A project key (`relia_live_…`) or an upload token won't work here. - **"Relia isn't reachable at …"**: the install could not reach Relia. Check your network or proxy, then run it again. - **A message about verifying your e-mail**: after the first 7 days, an unverified account can't read Relia from the app or from an AI tool. Verify your e-mail address, then try again. - **"Which project?" or "No project … in reach of this token"**: you have several projects, or the connection only covers some. Say which project (its id or name), or reconnect and allow that project. - **Too many requests:** each token or sign-in can make 300 calls an hour. Wait and try again. - **Remove Relia everywhere and start over:** `npx relia-sdk@latest mcp uninstall`, then install again. #### Check it worked Ask your assistant: ```text Use Relia: what needs my attention? ``` It answers from your Relia project, in plain words, with the problems Relia found. #### Next - [Connect your AI assistant](https://tryrelia.com/docs/connect-ai-assistant.md) - [Tokens and connected tools](https://tryrelia.com/docs/tokens-and-connected-tools.md) - [MCP tools](https://tryrelia.com/docs/mcp-tools.md) - [CLI reference](https://tryrelia.com/docs/cli.md#mcp) ### Get help with Relia > Get an answer right away from Relia's help articles, and reach a person at Relia when you need one. Section: When something doesn't work · Page: https://tryrelia.com/docs/getting-help · Last checked against the product: 2026-11-01 Video walkthrough: https://youtu.be/uhGB2AkjaNw When you're stuck, ask Relia first: it answers right away from Relia's help articles. If that doesn't solve it, a person is one click away. #### Open Help & support At the bottom of the menu in the app, click **Help & support**. The page has three parts: **Ask Relia first**, **Your requests**, and the **Guides** grouped by topic. #### Ask Relia first The **Ask Relia first** box is also the search. Type your question, or pick an example such as **Nothing shows up after setup**. The answer comes from Relia's help articles and names the articles it used. Then Relia asks **Did this solve it?** - **That solved it**: you're done. - **I still need a person**: the request form opens with your question filled in, and Relia's answer is attached, so you don't have to repeat it. If the question isn't covered by the articles, Relia says so and suggests passing it to the team. #### Write to a person Click **Ask a person** (or **I still need a person** after an answer). In the **Ask for help** form: 1. Under **What is it about?**, pick one: **Something is broken**, **A question**, **Billing**, **My account** or **Something else**. 2. Check the **Project** (or choose **Not about a project**). 3. Write a short subject and the details: what happened, what you expected, and since when. Steps to see it again help a lot. While you type the subject, Relia suggests articles that might already answer it. 4. If you picked **Something is broken** and your product is down or customers can't use it, tick **My product is down or customers can't use it.** These are looked at first. 5. Click **Send request**. > **Important:** never send passwords, API keys or card numbers in a request. The form attaches the page you were on, so the team can see what you see. #### After you send it - Your request opens on its own page with the status **Waiting on us**, and you get an e-mail confirming it. - A person at Relia reads every request and usually answers within one working day. - When the team answers, you get an e-mail and a badge on **Help & support**. The status changes to **We replied**. - Reply on the request's page, or click **This is solved**. Writing again on a solved request opens it again. All your requests are listed under **Your requests**. You only see your own. #### Ideas and feedback For ideas rather than problems, use **Give feedback** at the bottom of the menu. Every message reaches the team. #### Before you write: quick answers - Nothing arrives in Relia: [Relia shows no data](https://tryrelia.com/docs/no-data.md). - Browser errors show minified code: [Upload source maps](https://tryrelia.com/docs/source-maps.md). - Your AI assistant can't reach Relia: [Fix the MCP connection](https://tryrelia.com/docs/mcp-connection.md). - Plans, limits and billing: [Plans and limits](https://tryrelia.com/docs/plans-and-limits.md). > **Tip:** watch [A tour of Relia: every part of your product in one place](https://youtu.be/xdjhnok11dY) (2 min). #### Next - [What is Relia](https://tryrelia.com/docs/what-is-relia.md) - [Plans and billing](https://tryrelia.com/docs/plans-and-billing.md) - [Privacy in Relia](https://tryrelia.com/docs/privacy.md) ### CLI reference > Every command and flag of Relia's command-line tools for Node.js, Python and Laravel. Section: Reference · Page: https://tryrelia.com/docs/cli · Last checked against the product: 2026-11-01 Relia's command-line tool comes with the `relia-sdk` package (npm and PyPI) and, for Laravel, as an Artisan command in `tryrelia/relia`. > **Important:** always run the npm CLI as `npx relia-sdk@latest …`. The npm name `relia` belongs to someone else. Inside a project that has `relia-sdk` installed, scripts in `package.json` can call the local binary `relia` (this is what `init` writes into build scripts). #### Node.js CLI (`npx relia-sdk@latest`) | Command | What it does | |---|---| | `init` | Sets up Relia in the current folder (see [init](#init)). Also runs when you give no command. | | `token` | Writes the upload-only `RELIA_TOKEN` for this folder's project to `.env.local` (see [token](#token)). | | `sourcemaps upload ` | Uploads a build's source maps to Relia, then removes them from the folder (see [sourcemaps upload](#sourcemaps-upload)). | | `mcp` | Runs Relia's MCP connector over stdio. AI tools start this in token mode; you don't run it yourself. `mcp serve` and `mcp start` do the same. | | `mcp install` | Adds Relia to every AI tool found on this computer (see [mcp](#mcp)). | | `mcp uninstall` | Removes Relia from those tools and forgets the saved MCP token. | | `mcp status` | Shows the saved token (last 4 characters), the Relia address, and per tool: **set up**, **not installed** or **installed, Relia not added**. | | `mcp help` | Prints the `mcp` usage and the tool ids. | | `system` | Runs a standalone reporter for this machine's CPU, memory and disk (see [system](#system)). | | `whoami` | Shows who the CLI is signed in as. | | `logout` | Signs the CLI out (removes `~/.relia/auth.json`). | ##### init ```bash npx relia-sdk@latest init ``` No flags. It asks: 1. **How to sign in** (first time only): e-mail and password in the terminal, or an access token copied from the app. The login is saved in `~/.relia/auth.json`. 2. **What should Relia set up?** The first choice, **Everything Relia found here: …**, sets up every part it detected (an API, a web app, Next.js, AI SDK calls), also in `backend/` and `frontend/` style subfolders. Or pick one kind: log & API monitoring, session monitoring, or agent monitoring. (Not asked in a Laravel app.) 3. **Which project**: one of yours, a new one (name defaults to the folder), or a project id typed by hand. 4. **What to record in a browser app**: 1) clicks, pages and errors (default), 2) the same plus screen replays, 3) page views only. 5. **Tell Relia who your users are?** (default yes): prints the lines to add where your app knows the signed-in user. It then writes the config files (`relia.tracing.js`, `instrumentation.ts`, `src/relia.ts`, `relia.agent.js`…), patches your entry files, installs `relia-sdk`, writes `RELIA_*` values to `.env.local` for agent monitoring, and for web apps wires source maps and writes the upload token. In a Laravel app it runs `composer require tryrelia/relia` and `php artisan relia:install` for you. Answers can be piped in (CI). ##### token ```bash npx relia-sdk@latest token [--project-id ] ``` | Flag | What it does | Default | |---|---|---| | `--project-id ` | The project the token is for. | `RELIA_PROJECT_ID`, else the project id found in the folder's Relia files | The token can only upload source maps for that one project. A new one replaces your previous upload token for that project. Signs you in first if needed. ##### sourcemaps upload ```bash npx relia-sdk@latest sourcemaps upload ./dist --project-id ``` | Argument or flag | What it does | Default | |---|---|---| | `` | Build output to scan for `.map` files (recursively). | `dist` | | `--project-id ` | The Relia project. | `RELIA_PROJECT_ID` | | `--release ` | A release name. Optional: maps are matched by the bundle's file name. | `RELIA_RELEASE` | | `--keep` | Keep the `.map` files in the folder after uploading. | Off: they are deleted | | `--api-url ` | Relia's API address. | `RELIA_API_URL`, else Relia's cloud | | `--build-step` | For use inside a build script: a failed upload prints a warning and exits 0, and the maps are still removed. | Off | Flags also accept `--flag=value`. Token: `RELIA_TOKEN` (from the environment, or from `.env.local` / `.env` in the current folder), else the login saved by `init`. ##### mcp ```bash npx -y relia-sdk@latest mcp install [--only ] [--url
] [--token ] ``` | Flag | What it does | Default | |---|---|---| | `--only ` | Comma-separated tool ids: `claude-code`, `cursor`, `vscode`, `windsurf`, `codex`, `antigravity`, `gemini-cli`, `claude-desktop`. | Every tool found | | `--url
` | Relia's MCP address. | `RELIA_MCP_URL`, else `RELIA_API_URL` + `/mcp`, else `https://devreliaapi.tryrelia.com/mcp` | | `--token ` | Token mode: checks the `relia_mcp_…` token, saves it in `~/.relia/mcp.json`, and each tool starts the connector. Without it, each tool signs in with Relia in the browser. | `RELIA_MCP_TOKEN`, else sign-in mode | In sign-in mode, Claude Desktop gets **one step left**: add Relia under **Settings → Connectors**. See [Connect your AI assistant](https://tryrelia.com/docs/connect-ai-assistant.md). ##### system ```bash npx relia-sdk@latest system --project-id ``` | Flag | What it does | Default | |---|---|---| | `--project-id ` | The Relia project (required). | `RELIA_PROJECT_ID` | | `--service-name ` | The name shown in Relia. | `RELIA_SERVICE_NAME`, else the machine's host name | | `--interval ` | How often to report (at least 5). | `RELIA_SYSTEM_INTERVAL`, else 30 | | `--otlp-endpoint ` | Where to send the data. | `RELIA_OTLP_ENDPOINT`, else Relia's cloud | It runs until you stop it (Ctrl+C). The Node.js and Python SDKs already report the machine they run on; use this for a machine without them. ##### Settings the CLI reads | Variable | What it does | |---|---| | `RELIA_API_URL` | Relia's API address (default: Relia's cloud). | | `RELIA_APP_URL` | Relia's app address used in printed links (default `https://app.tryrelia.com`). | | `RELIA_OTLP_ENDPOINT`, `RELIA_SESSION_ENDPOINT`, `RELIA_AGENT_ENDPOINT` | Addresses `init` writes into the generated files instead of the cloud defaults. | All other variables are in [Environment variables](https://tryrelia.com/docs/environment-variables.md). #### Python CLI (`relia`) Install with `pip install relia-sdk`. The package adds the commands `relia` and `relia-system-monitor`. | Command | What it does | |---|---| | `relia init` (or `relia`, or `python -m relia`) | Sets up Relia in the current folder: signs in, picks or creates the project and service, writes `RELIA_PROJECT_ID`, `RELIA_KEY`, `RELIA_SERVICE_NAME` and `RELIA_OTLP_ENDPOINT` to `.env` (or `.env.local` when only that exists), generates `relia_tracing.py`, patches your entry file, and asks whether to tell Relia who your users are. For agent monitoring it writes `RELIA_PROJECT_ID`, `RELIA_KEY`, `RELIA_AGENT_ID`, `RELIA_AGENT_NAME` and `RELIA_AGENT_ENDPOINT` and generates `relia_agent.py` instead. | | `relia mcp install [--only ] [--url
] [--token ]` | Same as the Node.js `mcp install`. Without Python installed globally: `uvx --from relia-sdk@latest relia mcp install`. | | `relia mcp uninstall` | Removes Relia from your AI tools and forgets the saved token. | | `relia mcp status` | Shows the saved token and, per tool, **installed** or **not installed**. | | `relia mcp` | Runs the MCP connector over stdio (`serve` and `start` do the same). | | `relia whoami` | Shows who the CLI is signed in as. | | `relia logout` | Signs the CLI out. | | `relia help` (or `--help`, `-h`) | Lists the commands. | | `relia-system-monitor` (or `python -m relia.system`) | Standalone CPU, memory and disk reporter. Flags `--project-id` (required, default `RELIA_PROJECT_ID`), `--service-name` (default `RELIA_SERVICE_NAME`, else `OTEL_SERVICE_NAME`, else `backend`), `--interval` (seconds, at least 5; default `RELIA_SYSTEM_INTERVAL`, else 30), `--otlp-endpoint` (default `RELIA_OTLP_ENDPOINT`, else Relia's cloud). | #### Laravel (`php artisan relia:install`) After `composer require tryrelia/relia`: ```bash php artisan relia:install --project= --key= --service= ``` | Option | What it does | Default | |---|---|---| | `--project=` | Your Relia project id (24 characters; on your project page under **Setup Guide & SDK**). | Asked | | `--key=` | The project key (`relia_live_…`, same place). | Asked; Enter skips it | | `--service=` | The name shown in Relia. | Your `app.name`, lower-case with dashes | It writes `RELIA_PROJECT_ID`, `RELIA_KEY` and `RELIA_SERVICE_NAME` to `.env` (replacing existing `RELIA_*` lines, touching nothing else), adds the same names to `.env.example` without the key, and prints how to add the browser part (`Relia.init` in `resources/js/app.js`, or `@reliaScript` in your main Blade layout). #### Next - [Environment variables](https://tryrelia.com/docs/environment-variables.md) - [Upload source maps](https://tryrelia.com/docs/source-maps.md) - [Connect your AI assistant](https://tryrelia.com/docs/connect-ai-assistant.md) - [Monitor a Laravel or PHP app](https://tryrelia.com/docs/laravel-php-setup.md) ### Environment variables > Every environment variable Relia's SDKs and command-line tools read, which SDK reads it, what it does and its default. Section: Reference · Page: https://tryrelia.com/docs/environment-variables · Last checked against the product: 2026-11-01 The variables your app and build can set to configure Relia. "Node" = `relia-sdk` on a server (`relia-sdk/node`), "Python" = `relia-sdk` on PyPI, "PHP" = `tryrelia/relia` (Laravel and plain PHP), "Edge" = `relia-sdk/edge` (Supabase Edge Functions, Deno, Cloudflare Workers, Vercel Edge). Switches turn off with `0`, `false`, `off` or `no` unless a row says otherwise. > **Note:** the browser SDK (`Relia.init`) reads no environment variables: its settings are the options in `src/relia.ts`. The Node.js server SDK takes `serviceName` and `projectId` from `relia.tracing.js` (or `instrumentation.ts`), which `init` writes for you. The Python SDK also reads `.env` and `.env.local` in the current folder for variables not already set. Edge reads each variable from the function's options, then the Workers `env` bindings, then `Deno.env` / `process.env`. #### Project and identity | Variable | SDKs | What it does | Default | |---|---|---|---| | `RELIA_PROJECT_ID` | Python, PHP, Edge, Node (AI runs, CLI) | Your Relia project id (24 characters; on your project page under **Setup Guide & SDK**). | None. PHP sends nothing without it. | | `RELIA_KEY` | Node, Python, PHP, Edge | The project key (`relia_live_…`), sent as the `X-Relia-Key` header. A wrong key for the project is refused; a missing one is accepted. | None | | `RELIA_SERVICE_NAME` | Python, PHP, Edge, Node (`system`) | The service name shown in Relia. | Python: `OTEL_SERVICE_NAME`, else `backend`. PHP: your `APP_NAME` in lower case with dashes, else `php-app`. Edge: the first part of the URL path, else `edge-function`. | | `OTEL_SERVICE_NAME` | Python | Used when `RELIA_SERVICE_NAME` is not set. | None | | `RELIA_ENV` | Python, PHP, Edge | The environment name (production, staging…). Relia hides hosts from development environments by default. | Python: `ENVIRONMENT`, else `APP_ENV`, else `production`. PHP: `APP_ENV`, else `production`. Edge: `production`. | | `NODE_ENV` | Node | The environment name on Node.js servers. | `development` | #### Where data goes | Variable | SDKs | What it does | Default | |---|---|---|---| | `RELIA_OTLP_ENDPOINT` | Node, Python, PHP, Edge, CLI | Where traces go. `/v1/traces` is added when missing (Node, PHP). App logs go to the same address with `/v1/logs`. | `https://devotel.tryrelia.com/v1/traces` | | `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, `OTEL_EXPORTER_OTLP_ENDPOINT` | Python | Used, in that order, when `RELIA_OTLP_ENDPOINT` is not set. | None | | `RELIA_API_URL` | Node, Python, PHP, Edge, CLI | Relia's API address: SDK settings, AI runs, the Laravel `@reliaScript` browser part, and the CLI. | `https://devreliaapi.tryrelia.com` | #### Versions and deploys | Variable | SDKs | What it does | Default | |---|---|---|---| | `RELIA_RELEASE` | Node, Python, PHP, Edge, CLI, Vite plugin | The version of the running build, so Relia can tell deploys apart. Also the release name for source map uploads. | Detected (see below) | | `SERVICE_VERSION`, `OTEL_SERVICE_VERSION` | Node, Python, PHP | Used, in that order, when `RELIA_RELEASE` is not set. | None | With none of these set, the version is detected: first the commit your CI or host exposes (`GITHUB_SHA`, `VERCEL_GIT_COMMIT_SHA`, `RENDER_GIT_COMMIT`, `HEROKU_SLUG_COMMIT`, `SOURCE_VERSION`, `CF_PAGES_COMMIT_SHA`, `RAILWAY_GIT_COMMIT_SHA`, `CI_COMMIT_SHA`, `BITBUCKET_COMMIT`, `GIT_COMMIT`; PHP also `FORGE_SITE_BRANCH_COMMIT` and `LARAVEL_CLOUD_COMMIT`), then the checked-out commit in `.git`, then your package version. #### What is collected | Variable | SDKs | What it does | Default | |---|---|---|---| | `RELIA_ENABLED` | PHP, Edge | Switch: off sends nothing. | On | | `RELIA_TRACING_DISABLED` | PHP | Any value turns Relia off. | Not set | | `RELIA_LOGS` | Node, Python, PHP | Switch for sending your app's warning and error log lines. | On | | `RELIA_LOG_LEVEL` | Python, PHP | Lowest log level sent. | Python `WARNING`, PHP `warning` | | `RELIA_SYSTEM_METRICS` | Node, Python | Switch for CPU, memory and disk of the machine. Node turns off only with `false`. | On | | `RELIA_SYSTEM_INTERVAL` | Node, Python | Seconds between machine readings (at least 5). | `30` | | `RELIA_DISABLE_INSTRUMENTATIONS` | Node, Python | Comma-separated libraries not to trace. Node: `fastify`, `bullmq`, `mcp`. Python: `requests`, `httpx`, `aiohttp`, `celery`, `botocore`, `boto3sqs`, `mcp`. | None | | `RELIA_DB_BACKGROUND` | Node, Python | `1`, `true`, `yes` or `on` also records database calls made outside a request or job. | Off | | `RELIA_QUERIES` | PHP (Laravel) | Switch for database queries. | On | | `RELIA_HTTP_CLIENT` | PHP (Laravel) | Switch for outgoing HTTP calls. | On | | `RELIA_QUEUE` | PHP (Laravel) | Switch for queue jobs. | On | | `RELIA_REMOTE_SETTINGS` | Node, Python | Switch for reading the project's [SDK settings](https://tryrelia.com/docs/sdk-settings.md) from Relia (every 10 minutes). | On | #### AI calls and agent runs | Variable | SDKs | What it does | Default | |---|---|---|---| | `RELIA_AI_CAPTURE` | Node, Python, Edge | Switch for recording calls to OpenAI, Anthropic, Gemini and compatible APIs as AI runs. | On | | `RELIA_AGENT_ID` | Node, Python, Edge | The AI agent's id in Relia. | Node: derived from the agent name. Edge: the service name. | | `RELIA_AGENT_NAME` | Node, Python, Edge | The AI agent's name in Relia. | The service or package name | | `RELIA_AGENT_ENDPOINT` | Node, Python, Edge, CLI | Where AI runs are sent. | `https://devreliaapi.tryrelia.com/api/v1/agents/runs` | | `RELIA_DEBUG` | Node | Any value except `0`, `false` or `off` prints a line per AI run. | Off | #### Serverless functions | Variable | SDKs | What it does | Default | |---|---|---|---| | `RELIA_SERVERLESS` | Node, Python | `1`, `true` or `on` forces serverless mode (send before answering, no machine metrics). Detected by itself on Google Cloud / Firebase Functions, Cloud Run and AWS Lambda (Node also Vercel and Netlify). | Off | | `RELIA_FUNCTION_NAME` | Node, Python | The function's name when serverless mode is forced. | `function` | | `RELIA_FLUSH` | Node, Python, Edge | Node and Python: `after` keeps sending in the background instead of before each response. Edge: `before` always sends before answering (use it with `supabase functions serve`). | Node and Python: before answering in serverless mode, in the background otherwise. Edge: after answering when the platform keeps the function alive for it. | | `RELIA_FLUSH_TIMEOUT_MS` | Node, Python | Longest wait to send before answering, in milliseconds (Node: 100 to 5000). | `1000` | #### Command-line tools and builds | Variable | Used by | What it does | Default | |---|---|---|---| | `RELIA_TOKEN` | `sourcemaps upload`, Vite plugin | The upload-only token for source maps. Also read from `.env.local` / `.env` in the folder. Set it in your host's environment variables for hosted builds. | The login saved by `init` | | `RELIA_MCP_TOKEN` | `mcp`, `mcp install` | An MCP token (`relia_mcp_…`) for token mode. | `~/.relia/mcp.json` | | `RELIA_MCP_URL` | `mcp`, `mcp install` | Relia's MCP address. | `mcp`: the address saved by `mcp install`, else `https://devreliaapi.tryrelia.com/mcp`. `mcp install`: `RELIA_API_URL` + `/mcp`, else `https://devreliaapi.tryrelia.com/mcp`. | | `RELIA_SESSION_ENDPOINT` | `init` | The browser endpoint written into `src/relia.ts`. | Relia's cloud API | | `RELIA_APP_URL` | CLI | The Relia app address used in printed links. | `https://app.tryrelia.com` | #### Next - [CLI reference](https://tryrelia.com/docs/cli.md) - [Control what Relia collects](https://tryrelia.com/docs/sdk-settings.md) - [Relia shows no data](https://tryrelia.com/docs/no-data.md) - [Monitor serverless and edge functions](https://tryrelia.com/docs/edge-runtimes-setup.md) ### MCP tools > Every tool and ready-made prompt Relia's MCP server gives your AI assistant, with arguments, confirmations and plan notes. Section: Reference · Page: https://tryrelia.com/docs/mcp-tools · Last checked against the product: 2026-11-01 The tools your AI assistant gets once it is connected to Relia's MCP server at `https://devreliaapi.tryrelia.com/mcp` (see [Connect your AI assistant](https://tryrelia.com/docs/connect-ai-assistant.md)). Every tool acts as you: it only reads projects you can see, with your role in each. #### Rules for every tool | Rule | Details | |---|---| | `project` argument | Every tool except `relia_projects` and `relia_create_project` takes `project`: the project's id or name (up to 100 characters). It is optional when the connection reaches only one project. In a repository set up with Relia, the id is `RELIA_PROJECT_ID` in `.env.local`, or `project_id` in `src/relia.ts` / `relia.tracing.js`. | | Read-only by default | Every tool only reads, except the five marked "Yes" under **Confirm**. | | `confirm: true` | Actions do nothing until called with `confirm: true`. Without it, Relia answers with the question to ask you first. Your assistant should only set it after you say yes. | | Audit log | Every call is recorded in the project's audit log: reads as "AI assistant read Relia (MCP)", actions under their own name. | | Limit | 300 calls an hour per token or sign-in. | | Privacy | Answers never include who a visitor was, what they typed, or customers' names and e-mails (only counts and plan names). | #### Your projects and what needs you | Tool | What it returns | Arguments | Confirm | Plan notes | |---|---|---|---|---| | `relia_projects` | The projects this connection can read: id, name, plan, your role, number of services. | None | No | All plans | | `relia_status` | Relia's verdict: what needs you, each area's state (uptime, APIs, database, servers, page speed, users, AI agents) and the incidents that need a fix. | `project` | No | All plans | | `relia_list_incidents` | Incidents, most important first: id, severity, users affected, fix state. | `project`, `status` (`open` default, or `resolved`), `limit` (1 to 25, default 10) | No | All plans | | `relia_get_incident` | One incident: what happened, impact, what to do next, how it unfolded, evidence per layer with example trace ids, deploys around then, and the signed-in customers it hit (counts and plans only). | `project`, `incident_id` (required) | No | Free: the headline and size only, with a note that the explanation is on Growth and Pro. | | `relia_get_fix_plan` | Steps to fix an incident: root cause, files and lines, the change, how to verify. | `project`, `incident_id` (required) | No | Growth and Pro. Uses one of the month's fix plans the first time (Growth 30, Pro 50), then the stored plan is reused. Free answers with a plan message. | | `relia_ask` | An answer about your product's live data, citing its evidence. | `project`, `question` (required, up to 1,000 characters) | No | Uses the month's Ask Relia allowance (Free 30, Growth 100, Pro 300). | #### Evidence | Tool | What it returns | Arguments | Confirm | Plan notes | |---|---|---|---|---| | `relia_trace` | One request end to end: every span in order (services, database calls, outgoing calls) with durations, what failed and the error message. | `project`, `trace_id` (required; from incidents, logs or database results) | No | Traces are kept for your plan's history (7, 30 or 90 days). | | `relia_logs` | Warning and error log lines grouped by message pattern (count, last seen, code location, example traces). With `pattern`, that pattern's latest lines. | `project`, `search`, `service`, `level` (`warn` or `error`), `pattern`, `range` (`15m`, `1h`, `6h`, `24h` default, `7d`, `30d`) | No | All plans | | `relia_session` | One visit step by step: pages, clicks, failed requests and errors with their messages, rage clicks and stuck moments. Never who the visitor was or what they typed. | `project`, `session_id` (required; from an incident's evidence) | No | All plans | | `relia_database` | Database queries grouped without values, most total time first: calls, p95, failures, example slow or failed traces; plus N+1 patterns. | `project`, `service`, `range` (`15m`, `1h`, `6h`, `24h` default, `7d`, `30d`) | No | All plans | | `relia_vitals` | Page speed for real visitors: LCP, INP, CLS (and FCP, TTFB) at p75 with ratings, the change vs the period before, and the worst pages. | `project`, `range` (`24h`, `7d` default, `30d`) | No | All plans | | `relia_uptime` | Uptime monitors (up or down now, uptime %) and Relia's own checks of key pages and APIs (passing, failing step). | `project`, `range` (`24h` default, `7d`) | No | All plans | | `relia_changes` | Recent deploys Relia saw, changes reported to Relia, and incidents that began, newest first. | `project`, `hours` (1 to 336, default 48) | No | All plans | #### Dashboards and funnels | Tool | What it returns | Arguments | Confirm | Plan notes | |---|---|---|---|---| | `relia_dashboards` | The team's dashboards with their ids, and Relia's dashboard per service with why each is worth opening. | `project` | No | All plans | | `relia_dashboard` | One team dashboard read out panel by panel: the number now and its change, top items, monitors, checks and promises, open incidents, and what moved after a deploy or incident. | `project`, `dashboard_id` (required), `range` (`15m`, `1h`, `6h`, `24h`, `7d`, `30d`; default the dashboard's own), `service` | No | All plans | | `relia_funnels` | The journeys Relia follows (checkout, sign up…): how many people finished in the last 7 days vs the week before, the step where most are lost, and goals no funnel follows yet. | `project` | No | Why people leave each step: Growth and Pro. | #### Setup | Tool | What it returns | Arguments | Confirm | Plan notes | |---|---|---|---|---| | `relia_setup` | Exact steps to install Relia in the code open in your editor, for this project, including two choices for you (screen replays, identifying users). | `project` | No | Owners, admins and members (not viewers): the steps include the project key. | | `relia_check_setup` | What has arrived in Relia: requests per service, browser sessions, source maps, identified users, AI agent runs, each with the step left. | `project` | No | All plans | #### Actions (asks you first) | Tool | What it does | Arguments | Confirm | Plan notes | |---|---|---|---|---| | `relia_mark_fixed` | Tells Relia an incident is fixed. Relia watches real traffic and confirms the fix worked, or says it is still happening (usually 15 to 30 minutes after the fix is live). | `project`, `incident_id` (required), `note` (what changed, up to 500 characters), `confirm` | Yes | Any member. Only for an open incident. | | `relia_set_verdict` | Teaches Relia about an incident: `correct` (real), `wrong` (false alarm), `expected` (by design, stop raising it), `mute`, or `bug` (always needs a fix). | `project`, `incident_id` (required), `verdict` (required), `note` (up to 1,000 characters), `confirm` | Yes | `expected`, `mute` and `bug` need an owner or admin. | | `relia_ack` | "I'm on it": stops paging the next person on call for this alert and acknowledges PagerDuty. | `project`, `incident_id` (required), `confirm` | Yes | Not viewers | | `relia_report_change` | Records a deploy, config change or feature flag Relia can't see, so it links problems to it. A deploy starts fix verification. | `project`, `service`, `kind` (`deploy` default, `config`, `flag`, `other`), `version`, `previous_version`, `note` (up to 500 characters), `confirm` | Yes | Not viewers. Same as the [Report changes API](https://tryrelia.com/docs/report-changes-api.md). | | `relia_create_project` | Creates a Relia project for a repository that has none, then points to `relia_setup`. | `name` (required, up to 100 characters), `timezone` (optional, for the daily summary), `confirm` | Yes | Needs a connection that covers all your projects. At most 5 an hour. Your account's plan rules apply. | #### Prompts Ready-made requests your tool lists (in Claude Code, for example, `/mcp__relia__fix-top`). | Prompt | Title | What it asks your assistant to do | |---|---|---| | `setup` | Set up Relia | Call `relia_setup`, ask you its two questions first, show every change before writing it, never commit, then check with `relia_check_setup` after you start the app. | | `check` | Is Relia receiving everything? | Call `relia_check_setup` and say what Relia receives and the one thing to do next. | | `status` | What needs my attention? | Call `relia_status`, and get the fix plan for anything that needs a fix. | | `fix-top` | Fix the most important problem | Pick the most important incident, read its evidence and fix plan, find the cause in your repository, show you the change before writing it, never commit, then offer `relia_mark_fixed` after you deploy. | | `deploy-check` | Did my last deploy break anything? | Find the latest deploy with `relia_changes`, then compare incidents, error logs and database queries before and after it. | | `review-pr` | Review this change against production | Check the routes, queries and pages in your current git diff against production with `relia_ask`, `relia_database`, `relia_vitals` and `relia_list_incidents`, and list the risks. | #### Next - [Connect your AI assistant](https://tryrelia.com/docs/connect-ai-assistant.md) - [Fix production bugs from your editor](https://tryrelia.com/docs/from-your-editor.md) - [Your AI assistant can't reach Relia](https://tryrelia.com/docs/mcp-connection.md) - [Tokens and connected tools](https://tryrelia.com/docs/tokens-and-connected-tools.md) ### Report changes API > Tell Relia about deploys, config changes and feature flags it can't see, from CI or a script, with one HTTP call. Section: Reference · Page: https://tryrelia.com/docs/report-changes-api · Last checked against the product: 2026-11-01 Relia sees a deploy by itself when a service starts sending a new version. For changes it can't see (a deploy before your app reports a version, a config edit, a feature flag), send one call to `POST /api/v1/changes`. A reported **deploy with a version** starts fix verification for open incidents on that service and is what Relia suggests rolling back to; other changes appear as recent changes on incidents that start soon after. Base address: `https://devreliaapi.tryrelia.com` #### POST /api/v1/changes Records one change. ##### Authentication | Method | How | Who | |---|---|---| | Project key | Header `X-Relia-Key: relia_live_…` (or `Authorization: Bearer relia_live_…`) | CI and scripts. Find the key on your project page under **Setup Guide & SDK**. | | Signed in | A Relia sign-in | Owners, admins and members of the project (not viewers). This is how the `relia_report_change` MCP tool sends it. | A key that belongs to another project is refused. Without a key or a sign-in the answer is 401. ##### Body (JSON) | Field | Type | Required | What it is | Default | |---|---|---|---|---| | `project_id` | string (up to 64) | Yes | Your Relia project id. | | | `service` | string (up to 120) | No | The service that changed, as named in Relia. | `""` | | `kind` | `deploy`, `config`, `flag` or `other` | No | What kind of change. | `deploy` | | `version` | string (up to 80) | No | The new version (a tag or commit). | `""` | | `previous_version` | string (up to 80) | No | The version before. | `""` | | `note` | string (up to 500) | No | A short description. | `""` | | `at` | ISO 8601 date-time | No | When it happened. A time without a zone is read as UTC. Kept within the last 24 hours and never in the future: older times become 24 hours ago, future times become now. | Now | ##### Response `201 Created` ```json { "id": "6a7f…", "at": "2026-11-01T09:30:00+00:00" } ``` | Status | Meaning | |---|---| | `201` | Recorded. | | `401` | No key and not signed in, or the key doesn't belong to this project. | | `403` | Signed in as a viewer, or not a member of the project. | | `404` | The project doesn't exist. | | `422` | A field is missing, too long, or `kind` is not one of the four values. | | `429` | More than 120 calls in an hour from one address. Wait and retry. | ##### Examples A deploy, from a terminal or any CI: ```bash curl -X POST https://devreliaapi.tryrelia.com/api/v1/changes \ -H "Content-Type: application/json" \ -H "X-Relia-Key: $RELIA_KEY" \ -d '{"project_id": "'"$RELIA_PROJECT_ID"'", "service": "checkout", "kind": "deploy", "version": "1.4.3", "previous_version": "1.4.2"}' ``` A feature flag turned on: ```bash curl -X POST https://devreliaapi.tryrelia.com/api/v1/changes \ -H "Content-Type: application/json" \ -H "X-Relia-Key: $RELIA_KEY" \ -d '{"project_id": "'"$RELIA_PROJECT_ID"'", "service": "web", "kind": "flag", "note": "new-checkout on for 50% of visitors"}' ``` A GitHub Actions step after your deploy step (store the key and id as repository secrets): ```yaml - name: Tell Relia about the deploy run: | curl -sS -X POST https://devreliaapi.tryrelia.com/api/v1/changes \ -H "Content-Type: application/json" \ -H "X-Relia-Key: ${{ secrets.RELIA_KEY }}" \ -d '{"project_id": "${{ secrets.RELIA_PROJECT_ID }}", "service": "api", "kind": "deploy", "version": "${{ github.sha }}"}' ``` > **Tip:** your AI assistant can send the same report with the `relia_report_change` tool, after you confirm. See [MCP tools](https://tryrelia.com/docs/mcp-tools.md). #### GET /api/v1/changes Lists a project's reported changes, newest first. For signed-in members of the project (any role); the project key is not accepted here. | Query parameter | Required | What it is | Default | |---|---|---|---| | `project_id` | Yes | Your Relia project id. | | | `limit` | No | How many, 1 to 200. | `50` | Response: ```json { "changes": [ { "id": "6a7f…", "service": "checkout", "kind": "deploy", "version": "1.4.3", "note": "", "at": "2026-11-01T09:30:00+00:00" } ] } ``` To see changes from your editor instead, ask your AI assistant: it uses `relia_changes`, which also lists the deploys Relia saw by itself. #### Next - [Did my deploy break anything?](https://tryrelia.com/docs/did-my-deploy-break.md) - [From alert to verified fix](https://tryrelia.com/docs/fix-and-verify.md) - [MCP tools](https://tryrelia.com/docs/mcp-tools.md) - [Environment variables](https://tryrelia.com/docs/environment-variables.md) ### Plans and limits > Every price, monthly allowance, limit and feature of Relia's Free, Growth and Pro plans. Section: Reference · Page: https://tryrelia.com/docs/plans-and-limits · Last checked against the product: 2026-11-01 Plans are per project. Every new account gets **14 days of Pro**, no card needed; after it, the project moves to Free unless you upgrade, and your data stays. Prices exclude tax. For how to upgrade, see [Plans and billing](https://tryrelia.com/docs/plans-and-billing.md). #### Prices | | Free | Growth | Pro | |---|---|---|---| | Monthly | $0 | $19 a month | $49 a month | | Yearly | | $180 a year ($15 a month) | $468 a year ($39 a month) | Subscriptions started before these prices keep their price. **Enterprise** (custom volume, longer history, invoices, priority support): write to relia@alaknandainfoplus.com. #### Data and size | | Free | Growth | Pro | |---|---|---|---| | Units a month | 250,000 | 5 million | 20 million | | History kept (requests, sessions, logs, AI runs) | 7 days | 30 days | 90 days | | Visitor trends kept | 30 days | 6 months | 1 year | | Services | 3 | 10 | Unlimited | | Team members (people and pending invites) | 1 | 5 | Unlimited | | Uptime monitors | 5 | 20 | 50 | | Relia's synthetic check runs a month | None | 20,000 | 60,000 | | Own dashboards | 2 | 10 | 30 | | Panels per dashboard | 6 | 20 | 30 | | Funnels Relia watches for a drop in conversion | 3 | 10 | 30 | ##### How units are counted One pool per project per calendar month (UTC): | What | Units | |---|---| | A request to your API | 1 | | A warning or error log line | 1 | | A minute of a user session | 35 | | An AI agent run | 5 | | A page view in page-views-only mode | 1 | You get an e-mail at 80 % and at 100 % of the pool. ##### Over the limit Nothing you already have is deleted, and Relia never cuts you off. New data is sampled: about 1 in 10 is kept, and errors and slow requests are always kept, until the next month or until you upgrade. **Paid extra use** (Growth and Pro, monthly billing only): keep everything past the pool at **$2 per million units**, up to a spending limit you set (at least $5). Only owners and admins can switch it on. #### Relia's AI each month Counts per project per month, renewed on the 1st (UTC). Out of allowance, Relia keeps finding problems and alerting you; only the written answers stop until the next month. | | Free | Growth | Pro | |---|---|---|---| | Ask Relia questions | 30 | 100 | 300 | | Fix plans ("How to fix it") | None | 30 | 50 | | Postmortems written | None | 10 | 30 | | Incident explanations | None | 2,000 | 5,000 | | Project brief rewrites | None | 10 | 30 | Ask Relia questions from your AI assistant (`relia_ask`) and fix plans from it (`relia_get_fix_plan`) use the same allowances. Answers in **Help & support** don't count. #### Features Detection is the same on every plan: Relia finds problems with the same rules on Free, Growth and Pro. | | Free | Growth | Pro | |---|---|---|---| | Relia finds problems and e-mails you the headline | Yes | Yes | Yes | | Why it happened, who it hit, what to do (incident explanations) | No | Yes | Yes | | Fix plans and postmortems | No | Yes | Yes | | Daily or weekly summary | No | Yes | Yes | | Relia learns your product: project brief, synthetic checks, promises (SLOs), monitor suggestions | No | Yes | Yes | | Alerts in Slack, ClickUp and Jira | No (e-mail) | Yes | Yes | | On-call rotation and PagerDuty | No | Yes | Yes | | Escalation to the next person on call, two-person approval for actions | No | No | Yes | | Your own funnels, and why people leave each step | No | Yes | Yes | | Dashboards on a TV screen, charts as PNG or CSV | No | Yes | Yes | | Public status page | Yes, Relia-branded | Your domain, logo and webhook | Your domain, logo and webhook | | Audit log | No | Yes | Yes | | Paid extra use past the pool | No | Yes | Yes | | AI assistant (MCP) | Status and incident headlines | Full, incl. explanations and fix plans | Full, incl. explanations and fix plans | | People (which customers a problem hit), Relia's own funnels | Yes | Yes | Yes | > **Note:** during the 14-day trial a project gets everything in Pro. #### Next - [Plans and billing](https://tryrelia.com/docs/plans-and-billing.md) - [Relia shows no data](https://tryrelia.com/docs/no-data.md) - [MCP tools](https://tryrelia.com/docs/mcp-tools.md) - [Team and roles](https://tryrelia.com/docs/team-and-roles.md) ## Guides (https://tryrelia.com/blog) - [Postgres Migration Froze Your App? ALTER TABLE Lock Fix](https://tryrelia.com/blog/postgres-migration-locked-table-site-down-alter-table) (2026-11-22): A simple ALTER TABLE during a deploy can freeze every query on that table. Learn why Postgres lock queues cause it, how to unblock a stuck migration, and how to run migrations safely. - [Supabase 'Invalid Refresh Token: Not Found' Logging Users Out](https://tryrelia.com/blog/supabase-invalid-refresh-token-not-found-users-logged-out) (2026-11-22): Users randomly signed out of your Supabase app with 'Invalid Refresh Token: Refresh Token Not Found'? Find the cause: duplicate clients, lost cookies, or session limits, and fix it. - [ResizeObserver Loop Completed With Undelivered Notifications](https://tryrelia.com/blog/resizeobserver-loop-completed-with-undelivered-notifications) (2026-11-21): Your error tracker is full of 'ResizeObserver loop completed with undelivered notifications' from a React app. Learn when it is harmless, how to find the real cause, and how to filter it without hiding real errors. - [Firebase auth/unauthorized-domain Error After Deploy: Fix](https://tryrelia.com/blog/firebase-auth-unauthorized-domain-error-fix) (2026-11-20): Google or GitHub sign-in works on localhost but fails on your live site with auth/unauthorized-domain? Add the exact domain, handle preview URLs, and fix redirect sign-in on custom domains. - [Laravel Stripe Webhook Returns 419 or 400: Fix It](https://tryrelia.com/blog/laravel-stripe-webhook-419-csrf-signature-fix) (2026-11-20): Stripe shows your Laravel webhook failing with 419, 400, 301 or 503? Move the route out of CSRF, verify the signature on the raw body, and stop config caching from hiding your secret. - [Django 'DisallowedHost: Invalid HTTP_HOST Header': Fix](https://tryrelia.com/blog/django-disallowedhost-invalid-http-host-header-fix) (2026-11-19): Your live Django site returns 400 Bad Request with 'Invalid HTTP_HOST header'? Read the host in the message, fix ALLOWED_HOSTS, and stop settings from being overwritten or the proxy from sending the wrong Host. - [On-Call for a Small Team With No DevOps: A Simple Setup](https://tryrelia.com/blog/on-call-rotation-small-team-no-devops) (2026-11-19): Three developers and a live product, but nobody owns incidents? Set up a weekly on-call rotation, pick the few alerts that may wake someone, write one-page runbooks and keep the load fair. - [MySQL 'Deadlock Found When Trying to Get Lock': Fix](https://tryrelia.com/blog/mysql-deadlock-found-when-trying-to-get-lock-fix) (2026-11-18): Your app logs MySQL error 1213 and some requests fail at random. Find the two queries that collide, shorten the lock window, and add a safe retry. - [Cloudflare Workers Error 1101 'Worker Threw Exception': Fix](https://tryrelia.com/blog/cloudflare-workers-error-1101-worker-threw-exception) (2026-11-17): Your Worker returns Cloudflare error 1101 and the page gives no details. Turn on logs, find the real exception, fix the usual causes, and make the next failure show up before users report it. - ['Edge Function Returned a Non-2xx Status Code': Fix (Lovable)](https://tryrelia.com/blog/edge-function-returned-a-non-2xx-status-code-lovable-supabase) (2026-11-17): Lovable or supabase-js shows 'Edge Function returned a non-2xx status code' and nothing else. Read the real error body, check secrets, auth and CORS, and add a way to see these failures in production. - [LLM API Bill Spiked? Find the Feature or User Behind It](https://tryrelia.com/blog/llm-api-bill-spiked-find-feature-or-user-cause) (2026-11-16): Your OpenAI or Claude bill jumped and the dashboard shows only totals. Log tokens per feature and user, cap retries, and set limits so the next spike is caught in hours. - [Uptime Monitor Says Up but Users See Errors: Why and Fix](https://tryrelia.com/blog/uptime-monitor-says-up-but-site-is-broken) (2026-11-16): Your uptime monitor is green but customers cannot sign up or pay. Learn why a 200 response hides real failures and add deep health checks, body assertions and one flow check. - [Celery Tasks Not Executing in Production: Worker Fix](https://tryrelia.com/blog/celery-tasks-not-executing-production-worker-fix) (2026-11-15): Celery tasks are queued but nothing happens? Check the worker, the broker URL, the queue name, eager mode and task registration, in that order, with the exact commands. - [Postgres 'Remaining Connection Slots Are Reserved' Error: Fix](https://tryrelia.com/blog/postgres-remaining-connection-slots-reserved-superuser-fix) (2026-11-15): Postgres says remaining connection slots are reserved for superusers and your app is down? Find who holds the connections, free them, and size your pools so it stays fixed. - [Express Session Cookie Not Set in Production: trust proxy Fix](https://tryrelia.com/blog/express-session-cookie-not-set-production-trust-proxy) (2026-11-14): Login works locally but express-session sets no cookie on your live Node.js site? Learn why secure cookies fail behind a proxy, and fix it with trust proxy, forwarded headers and the right cookie options. - [Replit App Works in Preview but Fails After Publish: Fix](https://tryrelia.com/blog/replit-app-works-in-preview-fails-after-publish) (2026-11-14): Your Replit app runs fine in the workspace but shows errors or a blank page after you publish? Check deployment secrets, the run command, localhost URLs and logs, in the order that finds the cause fastest. - [Laravel 500 Error After Deploy and Nothing in the Logs: Fix](https://tryrelia.com/blog/laravel-500-server-error-after-deploy-no-logs) (2026-11-13): Your Laravel site shows a plain 500 after a deploy and storage/logs is empty? Find the real error in minutes by checking permissions, the .env file, APP_KEY, cached config and the web server log. - [Google OAuth redirect_uri_mismatch in Production: Fix](https://tryrelia.com/blog/google-oauth-redirect-uri-mismatch-production-fix) (2026-11-12): Google sign-in works on localhost but shows Error 400: redirect_uri_mismatch on your live site? Find the exact URI your app sends and make it match the Google Cloud console, character by character. - [Django 'CSRF Verification Failed' in Production: Fix](https://tryrelia.com/blog/django-csrf-verification-failed-origin-checking-failed) (2026-11-11): Login or forms work locally but return 403 'CSRF verification failed. Origin checking failed' on your live Django site? Fix CSRF_TRUSTED_ORIGINS, the proxy header and cookie settings. - [Supabase Edge Function CORS Error: Fix the Preflight](https://tryrelia.com/blog/supabase-edge-function-cors-error-preflight-fix) (2026-11-11): Calling a Supabase Edge Function from the browser fails with a CORS preflight error? Handle OPTIONS first, add headers to every response, and find the real error hiding behind it. - [Cron Job Stopped Running Silently? How to Monitor Cron Jobs](https://tryrelia.com/blog/cron-job-stopped-running-silently-how-to-monitor) (2026-11-10): Cron jobs and scheduled tasks fail without telling anyone. Add heartbeat pings so you get an alert when a backup, invoice run or email job does not finish on time. - [Redis 'OOM Command Not Allowed' Error: Find the Cause and Fix](https://tryrelia.com/blog/redis-oom-command-not-allowed-maxmemory-fix) (2026-11-10): Redis rejecting writes with OOM command not allowed when used memory exceeds maxmemory? Check the policy, find the keys eating memory, and pick a fix that does not lose sessions or queued jobs. - [Vite Blank Page After Deploy: MIME Type text/html Error](https://tryrelia.com/blog/vite-blank-page-after-deploy-mime-type-text-html) (2026-11-09): Your Vite or React app shows a white page after deploy and the console says the server responded with a MIME type of text/html? Find which file returns HTML and fix the base path, the SPA fallback or the cache. - [MongoDB Query Slow? Find COLLSCAN and Add the Right Index](https://tryrelia.com/blog/mongodb-query-slow-collscan-add-index-fix) (2026-11-08): A MongoDB or Mongoose query that got slow as data grew is usually a full collection scan. Find the slow query, read explain(), and add a compound index that fixes it. - [Vite 'Failed to Fetch Dynamically Imported Module' After Deploy](https://tryrelia.com/blog/vite-failed-to-fetch-dynamically-imported-module-after-deploy) (2026-11-08): Users see a blank page or a broken route right after you deploy a Vite app? Learn why old chunks return 404, and fix it with a safe reload handler and a better deploy setup. - [AWS Lambda 'Task Timed Out' and API Gateway 502/504: Fix](https://tryrelia.com/blog/aws-lambda-task-timed-out-api-gateway-502-fix) (2026-11-07): Lambda logs 'Task timed out after 3.00 seconds' and your API returns 502 or 504? Find the slow step, check VPC networking, and set timeouts that fit API Gateway. - [Laravel 419 Page Expired on Login in Production: Fix](https://tryrelia.com/blog/laravel-419-page-expired-login-production) (2026-11-07): Login works locally but returns 419 Page Expired on your live Laravel site? Check cookies, HTTPS, session storage, load balancers and cached pages in the right order. - [FastAPI Slow or Hanging Under Load? Blocking async def Fix](https://tryrelia.com/blog/fastapi-slow-all-requests-hang-async-def-blocking) (2026-11-06): One slow FastAPI request makes every other request wait, even a health check? Find the blocking call inside async def, then fix it with def, httpx or run_in_threadpool. - [Firebase Function 'PERMISSION_DENIED' on Firestore: Fix](https://tryrelia.com/blog/firebase-functions-permission-denied-firestore-fix) (2026-11-05): Your Cloud Function deploys fine but fails with 7 PERMISSION_DENIED when it touches Firestore. Check the emulator, the service account and the auth context. - [MySQL 'Too Many Connections' (Error 1040): Find and Fix](https://tryrelia.com/blog/mysql-too-many-connections-error-1040-fix) (2026-11-05): Your app throws MySQL error 1040 and new requests fail. Find which clients hold the connections, fix the leak, and raise max_connections safely. - [Gunicorn WORKER TIMEOUT and 502 on Django: How to Fix](https://tryrelia.com/blog/django-gunicorn-worker-timeout-502-fix) (2026-11-04): Your Django app returns 502 Bad Gateway and gunicorn logs [CRITICAL] WORKER TIMEOUT? Find the slow request, match proxy and gunicorn timeouts, and size workers correctly. - [Laravel Queue Jobs Not Processing in Production: Fix](https://tryrelia.com/blog/laravel-queue-jobs-not-processing-production) (2026-11-04): Jobs pile up in your Laravel queue and nothing runs? Check the worker, the connection name, stale code after deploy, and the failed jobs table, in that order. - [Lovable Supabase Login Fails After Publish: Redirect Fix](https://tryrelia.com/blog/lovable-login-redirects-to-localhost-after-publish) (2026-11-04): Login works in the Lovable preview but sends users to localhost or back to the login page after publishing? Fix the Supabase Site URL, redirect URLs and OAuth callback. - [Next.js 'TypeError: fetch failed' (ECONNREFUSED): Fix](https://tryrelia.com/blog/nextjs-typeerror-fetch-failed-econnrefused-fix) (2026-11-03): Server-side fetch throws 'TypeError: fetch failed' with ECONNREFUSED in Next.js? Read the real error in err.cause, then fix build-time fetches, localhost IPv6 and hardcoded URLs. - [Next.js Images Broken in Production but Fine Locally: Fix](https://tryrelia.com/blog/nextjs-image-works-locally-broken-in-production) (2026-11-02): next/image works on your laptop but shows broken images after deploy, with 'upstream response is invalid' or a 400 on /_next/image. Find which of five causes it is by testing one URL. - [Next.js 'Client-Side Exception Has Occurred': How to Fix](https://tryrelia.com/blog/nextjs-client-side-exception-has-occurred-fix) (2026-11-01): Your Next.js app shows a white page that says 'Application error: a client-side exception has occurred'. Find the real error behind it, match it to a cause, and add a fallback so users never see it again. - [Vercel Cron Job Not Running? 7 Causes and How to Fix Them](https://tryrelia.com/blog/vercel-cron-job-not-running) (2026-10-31): Your Vercel cron job never fires, or fires with no logs? Check the seven usual causes in order: production only, plan limits, caching, redirects, middleware, the secret check, and UTC. - [Next.js 'Error Occurred in the Server Components Render': Fix](https://tryrelia.com/blog/nextjs-server-components-render-error-omitted-production) (2026-10-30): Production shows 'An error occurred in the Server Components render. The specific message is omitted' and no clue why? Use the digest to find the real error, then fix it and show users a safe fallback. - [Cannot Set Headers After They Are Sent to the Client: Fix](https://tryrelia.com/blog/cannot-set-headers-after-they-are-sent-to-the-client) (2026-10-29): Seeing ERR_HTTP_HEADERS_SENT in Express or a Next.js API route? Find the line that sends a second response, fix the five usual patterns, and make your error handler safe. - [Next.js 'Failed to Find Server Action' Error: Fix It](https://tryrelia.com/blog/nextjs-failed-to-find-server-action-production-fix) (2026-10-28): Server actions work in dev but throw 'Failed to find Server Action' in production? Learn the four usual causes (version skew, multiple servers, stale builds, bot traffic) and how to fix each. - [API Endpoint Getting Slower as Data Grows? Find the Cause](https://tryrelia.com/blog/api-endpoint-slower-as-data-grows) (2026-10-27): An endpoint that was fast last week and is slow today, with no deploy in between, usually reads more than it needs or asks the database once per item. Learn how to spot the drift in p95, find which of the two it is, and fix both without changing what the endpoint returns. - [Postgres Query Slow in Production but Fast Locally: Why](https://tryrelia.com/blog/postgres-query-slow-in-production-fast-locally) (2026-10-27): Your query runs in milliseconds on your laptop and crawls in production. Learn the five usual causes, how to tell them apart with EXPLAIN and pg_stat_statements, and how to fix each one. - [Status Page for a Small SaaS: What to Show and How](https://tryrelia.com/blog/status-page-small-saas-guide) (2026-10-25): A practical guide to a status page for a small SaaS: components named the way customers think, automatic updates from outside checks, incident wording, uptime bars, feeds and webhooks, a custom domain, and what never to publish. - [Which Customers Hit That Error? Identify Users in Production](https://tryrelia.com/blog/which-customers-hit-error-identify-users) (2026-10-24): Tie errors and sessions to signed-in user ids and plans, so you know which paying customers hit a bug before they e-mail you. Browser, Node and Python code, plus the privacy rules that keep it safe. - [Build a Monitoring Dashboard Without Writing Queries](https://tryrelia.com/blog/monitoring-dashboard-without-writing-queries) (2026-10-23): A small product needs a handful of panels, not a wall of graphs. Which numbers matter, why every chart needs a 'compared with before' and deploy markers, and how to build it without learning PromQL, NRQL or SQL. - [Errors on One Browser, Device or Country: Find and Fix](https://tryrelia.com/blog/errors-one-browser-device-country-find-fix) (2026-10-22): Some bugs only hit Safari, old Android phones, one country or people with an ad blocker. Learn how to spot a segment that fails far more than the rest of your site, reproduce it on real devices, and fix the usual causes in code. - [Funnel Analysis Without Event Tracking or a Tracking Plan](https://tryrelia.com/blog/funnel-analysis-without-event-tracking) (2026-10-21): You do not need a tracking plan to see where people leave. Build funnels from the page views, clicks, form submits and API requests you already record, and avoid the pitfalls that make them lie. - [Why Users Drop Off at Checkout: Find the Step and the Cause](https://tryrelia.com/blog/why-users-drop-off-checkout-find-cause) (2026-10-20): Checkout drop-off is rarely a mystery once you compare the people who left with the people who paid. Here is a practical method to find the exact step and the technical cause behind it. - [BullMQ Failed Jobs: Monitor and Retry in Production](https://tryrelia.com/blog/bullmq-failed-jobs-monitoring-production-guide) (2026-10-19): Background jobs fail silently. Configure BullMQ retries, backoff, stalled job handling, dead-letter patterns, and alerts so failed jobs never pile up unnoticed. - [JWT Expired Errors in Production: Refresh Tokens Done Right](https://tryrelia.com/blog/jwt-expired-token-errors-production-api-guide) (2026-10-18): 'jwt expired' and random 401 logouts in production? Fix clock skew, concurrent refresh races, and silent token expiry with a single-flight refresh pattern. - [Nginx 502 Bad Gateway With Node.js: Causes and Fixes](https://tryrelia.com/blog/nginx-502-bad-gateway-nodejs-fix) (2026-10-17): Nginx shows 502 Bad Gateway in front of your Node app? Read the error log, then fix connection refused, wrong port, localhost binding, keep-alive, and crashed processes. - [Docker Exit Code 137 With Node.js: OOM Kill Fix Guide](https://tryrelia.com/blog/docker-exit-code-137-nodejs-oom-fix) (2026-10-16): Container exits with code 137 or Kubernetes shows OOMKilled? Confirm the OOM kill, set Node's heap below the container limit, and find what is eating memory. - [MongoServerSelectionError on Vercel: Atlas Connection Fix](https://tryrelia.com/blog/mongodb-server-selection-error-serverless-fix) (2026-10-16): MongoServerSelectionError or 'connection timed out' on serverless? Fix Atlas IP allowlists, client caching, pool size, and DNS so MongoDB connects reliably from Vercel. - [OpenAI API 429 and Timeout Errors in Production: Fix Guide](https://tryrelia.com/blog/openai-api-429-timeout-errors-production-guide) (2026-10-15): OpenAI 429 'rate limit' vs 'insufficient_quota', slow responses, and timeouts. How to tell them apart and build retries, queues, and fallbacks that keep your AI feature up. - [TanStack Query Error Handling in Production: Guide 2026](https://tryrelia.com/blog/react-query-error-handling-production-guide) (2026-10-14): React Query retries silently and swallows failures. Set up global error handling, retry rules, error boundaries, and logging so API failures never go unnoticed. - [TypeScript Types Lie at Runtime: Why Prod Still Crashes](https://tryrelia.com/blog/typescript-types-lie-runtime-errors-production) (2026-10-14): Your code is fully typed but production still throws undefined errors. Types vanish at runtime. Learn where they lie and how to validate boundaries with Zod and stricter compiler flags. - [Node.js Event Loop Blocked: Detect and Fix Slow Servers](https://tryrelia.com/blog/nodejs-event-loop-blocked-detect-fix) (2026-10-13): One slow request freezes every other request in Node.js. Learn to measure event loop lag, find the blocking code, and fix it with streams, chunking, and worker threads. - [React 'Maximum Update Depth Exceeded' Error: Fix Guide](https://tryrelia.com/blog/react-maximum-update-depth-exceeded-fix) (2026-10-13): 'Too many re-renders' and 'Maximum update depth exceeded' mean an infinite render loop. The 5 patterns that cause it, with before and after code for each. - [NextAuth Session Null in Production: 7 Causes and Fixes](https://tryrelia.com/blog/nextauth-session-null-production-fix) (2026-10-12): Login works locally but session is null on Vercel? Check NEXTAUTH_URL, secret, trustHost, cookies, callback URLs, and SessionProvider. Exact fixes for NextAuth and Auth.js. - [Node.js ECONNRESET Error: Causes and Production Fixes](https://tryrelia.com/blog/nodejs-econnreset-error-fix) (2026-10-12): 'read ECONNRESET' or 'fetch failed' in Node.js? The peer closed the socket. Learn the keep-alive mismatch behind most cases and how to fix it with retries and timeouts. - [Supabase RLS Errors in Production: Debug Empty Results](https://tryrelia.com/blog/supabase-rls-errors-production-debug-guide) (2026-10-11): Supabase returns an empty array or 'new row violates row-level security policy'? Learn why RLS fails silently, how to debug policies, and the service-role mistake to avoid. - [Vercel FUNCTION_INVOCATION_TIMEOUT (504): How to Fix It](https://tryrelia.com/blog/vercel-function-timeout-504-fix) (2026-10-11): Vercel returns 504 FUNCTION_INVOCATION_TIMEOUT when a function runs too long. Find the slow step, set maxDuration correctly, and move long work off the request path. - [Next.js 413 Payload Too Large: Fix File Upload Errors](https://tryrelia.com/blog/nextjs-413-payload-too-large-upload-fix) (2026-10-10): File uploads fail with 413 or 'Body exceeded 1MB limit' in Next.js? Where each limit lives (Server Actions, API routes, Vercel, nginx) and the upload pattern that avoids all of them. - [Next.js Environment Variables Undefined in Production: Fix](https://tryrelia.com/blog/nextjs-environment-variables-undefined-production-fix) (2026-10-10): process.env works locally but is undefined on Vercel? The 6 causes: NEXT_PUBLIC inlining, missing redeploy, wrong environment scope, dynamic keys, Edge runtime, and typos. - [ChunkLoadError After Deploy in Next.js: Fix Guide 2026](https://tryrelia.com/blog/nextjs-chunkloaderror-after-deploy-fix) (2026-10-09): Users get 'Loading chunk failed' right after you deploy? Version skew is the cause. Here is how to stop it with skew protection, caching rules, and a one-time reload. - [Next.js ERR_TOO_MANY_REDIRECTS: Fix Middleware Loops](https://tryrelia.com/blog/nextjs-middleware-redirect-loop-fix) (2026-10-09): Browser says 'redirected you too many times' after adding auth middleware? The 5 real causes of Next.js redirect loops and how to break each one. - [Next.js 'Dynamic Server Usage' Error: Causes and Fix](https://tryrelia.com/blog/nextjs-dynamic-server-usage-error-fix) (2026-10-08): Seeing 'Dynamic server usage: Route couldn't be rendered statically' in your Next.js build? Learn the 4 causes (cookies, headers, fetch, searchParams) and the exact fix for each. - [Next.js Server Actions Error Handling: Production Guide](https://tryrelia.com/blog/nextjs-server-actions-error-handling-production-guide) (2026-10-08): Server Action errors are sanitized in production and redirect() gets swallowed by try/catch. Here is how to return typed errors, show them in forms, and log the real cause. - [AI Code Review vs Runtime Bug Detection: What Wins in 2026](https://tryrelia.com/blog/ai-code-review-vs-autonomous-bug-fixing-2026) (2026-10-07): AI code review vs runtime bug detection: why PR-time checks miss production failures, and how catching, explaining and verifying fixes at runtime cuts MTTR in 2026. - [Error Budgets and SLOs for Startups: Practical Guide 2026](https://tryrelia.com/blog/error-budget-slo-guide-startups-2026) (2026-10-07): Master error budgets and SLOs for startups in 2026. Learn realistic SLI formulas, burn rate alerts, and how an observability agent protects velocity without enterprise bloat. - [Incident Postmortem Template for Startups 2026 + Example](https://tryrelia.com/blog/incident-postmortem-template-startups-2026) (2026-10-07): Blameless postmortem template with real SEV1 example for startups in 2026. Learn the 5 core rules to eliminate repeat incidents and slash MTTR. - [Next.js Deployment Failed on Vercel: Fix Build Errors](https://tryrelia.com/blog/nextjs-deployment-failed-vercel-fix-guide) (2026-10-07): Vercel Next.js deployment failed? Fix prerender crashes, dynamic server usage errors, missing build env vars, and memory limits with this comprehensive guide. - [OpenTelemetry vs Sentry vs Relia: Startup Guide 2026](https://tryrelia.com/blog/opentelemetry-vs-sentry-vs-relia-2026-guide) (2026-10-07): OpenTelemetry vs Sentry vs Relia in 2026: compare telemetry collection, error grouping, and plain-words incident explanations to build the ultimate lean startup stack. - [Rollbar vs Bugsnag vs Relia: Error Tracking Compared 2026](https://tryrelia.com/blog/rollbar-vs-bugsnag-vs-relia-2026-comparison) (2026-10-07): Rollbar vs Bugsnag vs Relia in 2026: compare real-time triage, mobile stability scoring, and plain-words incident explanations for modern engineering teams. - [Session Replay Debugging: Fix Production Errors Fast 2026](https://tryrelia.com/blog/session-replay-debugging-production-errors-guide) (2026-10-07): Struggling to reproduce production bugs with stack traces alone? Learn how session replay captures DOM states, clicks, and network calls to fix bugs fast. - [API Timeout Errors in Node.js: Retries That Work 2026](https://tryrelia.com/blog/api-timeout-errors-nodejs-retry-production-guide) (2026-10-06): Eliminate Node.js API timeout errors in production. Implement AbortController deadlines, exponential backoff with full jitter, and circuit breakers. - [500 Internal Server Error in Next.js: Debug Fast 2026](https://tryrelia.com/blog/nextjs-500-internal-server-error-production-fix) (2026-10-06): Next.js returning 500 in production? Trace error digests, Server Component crashes, and missing env vars fast with our proven production debugging guide. - [Redis Upstash Errors on Serverless: Fix Timeouts 2026](https://tryrelia.com/blog/redis-upstash-errors-serverless-production-guide) (2026-10-06): Fix Redis timeouts, Upstash rate limits, and serverless connection crashes. Master HTTP REST Redis, pipelining, cache stampede locks, and fail-open design. - [Slow TTFB in Next.js on Vercel: Cut It Under 500ms](https://tryrelia.com/blog/slow-ttfb-nextjs-vercel-optimization-guide) (2026-10-06): Is slow TTFB on Vercel hurting your Next.js Core Web Vitals? Cut latency under 300ms by eliminating cold starts, SSR waterfalls, and middleware bloat. - [Vercel Edge Runtime Errors: Debug Middleware Crashes](https://tryrelia.com/blog/vercel-edge-runtime-errors-debugging-guide) (2026-10-06): Debug Vercel Edge Runtime and Next.js middleware crashes. Learn isolate constraints, Node API incompatibilities, and production-tested architecture fixes. - [CORS Errors in Production: Next.js Fix Guide 2026](https://tryrelia.com/blog/cors-errors-production-nextjs-fix-guide) (2026-10-05): CORS policy blocked your Next.js API in production? Fix preflight OPTIONS, wildcard credentials bugs, Edge middleware, and Vercel subdomains fast. - [Database Connection Pool Exhaustion: Node.js Fix 2026](https://tryrelia.com/blog/database-connection-pool-exhaustion-nodejs-fix) (2026-10-05): Fix database connection pool exhaustion and 'too many clients already' in Node.js. Master PgBouncer, serverless connection multiplexing, and pooling code. - [Node.js Memory Leaks in Production: Detect and Fix 2026](https://tryrelia.com/blog/nodejs-memory-leak-detection-production-fix) (2026-10-05): Diagnose and fix Node.js memory leaks in production before OOM crashes. Master heap snapshots, V8 internals, closures, and automated root-cause detection. - [Prisma Errors in Production: Fix P2002, P2025, P1001 Fast](https://tryrelia.com/blog/prisma-errors-production-handling-p2002-p2025-fix) (2026-10-04): Master production Prisma error handling. Fix P2002 unique constraint violations, P2025 missing records, and P1001 connection pool crashes with code. - [Stripe Webhook Failures: Debug and Fix in Production 2026](https://tryrelia.com/blog/stripe-webhook-failures-production-debugging-guide) (2026-10-04): Stripe webhooks failing with 400 or 500 in production? Fix signature verification, raw body buffers, idempotency locks, and timeout drops step by step. - [Zod Validation Errors in Production APIs: Handle Like a Pro](https://tryrelia.com/blog/zod-validation-errors-api-production-guide) (2026-10-04): Prevent Zod validation errors from crashing APIs with 500s. Learn safeParse patterns, flattened error formatting, schema drift guards, and RFC 7807. - [Next.js API Routes Error Handling: Production Guide 2026](https://tryrelia.com/blog/nextjs-api-routes-error-handling-production-guide) (2026-10-03): Master Next.js API route error handling in App Router. Learn typed catch wrappers, Zod validation, status code mapping, and resilient production patterns. - [Next.js Hydration Mismatch Error: Causes and Production Fix in 2026](https://tryrelia.com/blog/nextjs-hydration-mismatch-error-fix-production) (2026-10-03): Fix Next.js hydration mismatch errors in production. Learn why server HTML differs from client React, how to debug minified errors, and robust 2026 fixes. - [7 Best Sentry Alternatives in 2026 for Production Error Tracking](https://tryrelia.com/blog/sentry-alternatives-2026) (2026-10-02): Sentry gets expensive at scale with rigid per-event quotas. Discover the best Sentry alternatives in 2026 for startups and production engineering teams. - [The Ultimate Startup Observability Stack Under $50 in 2026](https://tryrelia.com/blog/startup-observability-stack-under-50-2026) (2026-10-02): Don't burn your runway on Datadog. Here is exactly how to build a complete, enterprise-grade observability and error tracking stack for under $50 a month. - [7 Best Datadog Alternatives for Startups: Cheaper Error Tracking in 2026](https://tryrelia.com/blog/datadog-alternatives-startups) (2026-10-01): Datadog bills per host, per GB, and per session. Here are the top lightweight and cost-effective Datadog alternatives that startups use for observability and error tracking in 2026. - [PagerDuty Alternatives: How to Reduce Alert Fatigue and MTTR](https://tryrelia.com/blog/pagerduty-alternatives-reduce-alert-fatigue) (2026-09-30): PagerDuty wakes you up. These PagerDuty alternatives cut alert noise, auto-triage incidents, and lower MTTR by putting AI agents that explain incidents on the front line. - [PostHog Error Tracking: When It Works and When It Falls Short](https://tryrelia.com/blog/posthog-error-tracking-limitations) (2026-09-29): PostHog added error tracking with 100k exceptions free. It is excellent for correlating product impact with user behavior, but has notable limitations for deep backend debugging, distributed tracing, and automated bug resolution. - [Next.js Error Monitoring in Production: Complete Guide 2026](https://tryrelia.com/blog/nextjs-error-monitoring-production-guide) (2026-09-27): Next.js fails in 4 runtimes: browser, Node server, edge, and build. Here's how to monitor all of them without blind spots, understand the complexity of the App Router, and automate your debugging process. - [Node.js Production Error Handling: Stop Silent Crashes](https://tryrelia.com/blog/nodejs-production-error-handling-guide) (2026-09-26): Unhandled rejections kill Node.js silently. Here is the ultimate comprehensive production error handling guide for Node.js developers using Express, Fastify, and NestJS, preventing silent crashes and accelerating MTTR. - [React Error Boundaries in Production: Best Practices](https://tryrelia.com/blog/react-error-boundary-production-guide) (2026-09-25): Error boundaries stop white screens in React. Discover how to set them up per route, log with deep context, and recover gracefully to ensure a robust user experience in production. - [Unhandled Promise Rejection in Node.js and Next.js: Fix Guide](https://tryrelia.com/blog/unhandled-promise-rejection-nodejs-fix) (2026-09-24): Unhandled promise rejections crash Node.js with no logs. Learn the common causes, quick fixes, and how to track them down in complex Next.js applications. - [TypeError Cannot Read Properties of Undefined: Production Fix](https://tryrelia.com/blog/javascript-typeerror-cannot-read-properties-fix) (2026-09-23): TypeError: Cannot read properties of undefined is the most common JavaScript crash in production. Learn exactly why it happens, how to fix it quickly with modern JS features like optional chaining, and how to prevent it from ever reaching your users again using strict validation and an observability agent like Relia. - [Express Error Handling Middleware: Production Pattern](https://tryrelia.com/blog/express-error-handling-middleware-production) (2026-09-22): Express ignores async errors by default, meaning unexpected promise rejections can crash your server. Discover a robust production-ready error handling middleware pattern featuring request IDs, safe client responses, async wrapping, and automated bug fixing integration. - [Next.js Source Maps in Production: Debug Minified Stacks](https://tryrelia.com/blog/nextjs-source-maps-production-debugging) (2026-09-21): Minified Next.js stacks like chunks/724-abc.js are useless for debugging. Learn how to configure, generate, and upload source maps privately to debug production issues fast. - [Vercel Log Drains: Centralize Production Errors the Right Way](https://tryrelia.com/blog/vercel-log-drain-observability-guide) (2026-09-20): Vercel logs vanish after the lambda ends. Learn how to configure log drains to centralize Next.js errors, maintain request context, and actually fix bugs. - [Render and Railway Monitoring: Production Guide for Indie Teams](https://tryrelia.com/blog/render-railway-monitoring-guide) (2026-09-19): Render and Railway make deployment incredibly easy, but monitoring hard. Master health checks, log retention, and AI-driven monitoring specifically tailored for small and indie teams. - [Silent Frontend Failures Are Killing User Trust (and How to Catch Them)](https://tryrelia.com/blog/silent-frontend-failures-user-churn) (2026-09-18): Most users never report bugs — they just leave. Discover how silent frontend failures cause invisible churn, why they hurt more than crashes, and the strategies to catch them early. - [How to Reduce MTTR: Practical Guide for Production Incidents](https://tryrelia.com/blog/mttr-reduction-guide-production-incidents) (2026-09-17): MTTR is detect + diagnose + fix + verify. Learn how modern engineering teams cut production MTTR from 45 minutes to under 10 minutes using automated diagnostics, strategic rollbacks, AI-written fix plans, and automatic fix verification. - [Logs vs Error Tracking vs APM: What Startups Actually Need](https://tryrelia.com/blog/logs-vs-error-tracking-vs-apm-startups) (2026-09-16): Logs tell you what happened, error tracking tells you where the code broke, and APM tells you how slow your system is performing. Learn what you should invest in first as a startup and why getting the right observability stack can make or break your engineering velocity. - [AI Bug Fixer: How Autonomous Error Fixing Actually Works](https://tryrelia.com/blog/ai-bug-fixer-how-autonomous-fix-works) (2026-09-15): AI bug fixers are transforming the developer workflow. They go beyond simple autocomplete, actively intercepting runtime errors in production, reconstructing request context, diagnosing root causes, generating verified patches, and automatically opening pull requests to resolve the issue before users even notice. - [Self-Healing Code Explained: From Auto-Restart to AI Remediation](https://tryrelia.com/blog/self-healing-code-explained-2026) (2026-09-14): Self-healing code detects, diagnoses, and fixes its own failures. We explore the 3 levels of autonomy, essential safety guardrails, and why 2026 is the year AI-driven remediation goes mainstream. - [Model Context Protocol (MCP) for DevOps: Practical Monitoring Guide](https://tryrelia.com/blog/mcp-devops-production-monitoring-guide) (2026-09-13): MCP lets AI agents safely query deploys, logs, and analytics. Explore how engineering teams are leveraging this open standard to securely connect AI agents with infrastructure like Render, Railway, and PostHog for advanced incident response, real-time monitoring, and autonomous operations. - [Free Observability Tools for Startups in 2026 (That Actually Work)](https://tryrelia.com/blog/free-observability-tools-startups-2026) (2026-09-12): A comprehensive guide to the best free observability tools for startups in 2026. Discover how to leverage zero-cost uptime checks, error tracking, distributed tracing, and logging to build a robust monitoring stack before you reach product-market fit, along with next-gen AI observability agents. - [Simple Bug Tracking Tools for Small Teams (No DevOps Degree Needed)](https://tryrelia.com/blog/simple-bug-tracking-small-teams) (2026-09-11): We compare simple bug tracking tools for small teams: focus on flat pricing, 5-minute setup, intelligent grouping, and the rare tools that actually fix bugs for you. - [Easy-to-Use Error Tracking for Beginners: Setup in 10 Minutes](https://tryrelia.com/blog/easy-error-tracking-beginners-setup) (2026-09-10): New to error tracking? Discover the easiest tools for beginners, decode what each alert means, learn the fundamentals of stack traces, and confidently fix your first bug with a 10-minute setup guide. - [How to Find Production Bugs Before Users Report Them](https://tryrelia.com/blog/find-production-bugs-before-users-report) (2026-09-09): Users report under 5% of bugs. Waiting for support tickets is a surefire way to lose customers. Learn how to catch production bugs first using synthetic probes, real user monitoring, session replays, and AI-driven detection tools that explain errors and check your fixes against live traffic. - [Checkout Button Not Working? How to Debug a Dead Payment Button](https://tryrelia.com/blog/checkout-button-not-working-debug) (2026-09-08): When your checkout button does nothing on click, every second is lost revenue. In this deep dive, we explore the primary causes—from silent JavaScript errors and tricky race conditions to token expirations and payment API failures. Learn how to systematically debug front-end issues, monitor your core funnels, and resolve e-commerce blocking errors faster using advanced tooling and AI observability agents. - [How to Know When Your Website Is Down (Before Customers Tell You)](https://tryrelia.com/blog/know-website-down-immediately-alert) (2026-09-07): Learn how to set up external uptime monitoring in under 5 minutes. Discover what to ping, how to set alert thresholds that avoid alert fatigue, the best free tools to use, and how tools like Relia pair uptime checks with plain-words explanations so you can resolve issues before users ever complain. - [How to Find a Slow API Endpoint in Next.js (P50/P95 per Route)](https://tryrelia.com/blog/find-slow-api-endpoint-nextjs) (2026-09-06): Your API returns 200 OK but takes 8 seconds to load, causing users to abandon your app. Learn comprehensive strategies to find which Next.js route is slow using P50/P95 per-route latency tracking, eliminate N+1 database queries, and automate your debugging with AI-driven tools to keep production blazing fast. - [Too Many Production Alerts? How to Fix Alert Noise Fast](https://tryrelia.com/blog/too-many-production-alerts-fix-noise) (2026-09-05): Drowning in production alerts? Cut noise 80% with grouping, spike rules, and agent-first triage that fixes issues before they even page an engineer. - [Can't Reproduce a Production Bug Locally? Do This Instead](https://tryrelia.com/blog/cant-reproduce-production-bug-locally) (2026-09-04): Works locally, breaks in prod? Stop guessing and trying to recreate it blindly. Learn how to capture production context—payloads, traces, and session replays—and debug directly from hard evidence. We cover the biggest environment differences, strategies to isolate variables, and how AI-powered tools can explain these elusive issues and confirm your fix worked. - [What Production Bugs Really Cost a Startup (and How to Stop Paying)](https://tryrelia.com/blog/production-bugs-cost-startup-customers) (2026-09-03): One checkout bug can cost more than a year of tooling. We break down how production bugs drain revenue, damage brand trust, and the exact math that justifies fixing them before your customers even notice. ## Pages - [Relia](https://tryrelia.com/): The agent that watches your product, learns what's normal and tells you only what needs you, with the cause and the next step. - [Pricing](https://tryrelia.com/pricing): Free, Growth ($19 a month) and Pro ($49 a month), 14 days of Pro for every new account, and how units are counted. - [Set up Relia](https://tryrelia.com/setup): One command (npx relia-sdk@latest init, python -m relia, or composer require tryrelia/relia for Laravel, flutter pub add relia_flutter for Flutter) or your AI assistant over MCP; Relia finds your API, web app and mobile app and shows when data arrives. About five minutes. - [Relia MCP server](https://tryrelia.com/mcp): Connect Claude Code, Cursor, VS Code or any MCP client to Relia: your AI assistant reads incidents, evidence and fix plans from production. Read-only; status and headlines on Free, everything on Growth and Pro. - [Security and your data](https://tryrelia.com/security): What Relia collects and masks, who can see it, where it is stored, how long it is kept and what it never does. - [Compare Relia](https://tryrelia.com/compare): Relia side by side with the tools founders weigh, from each product's own pricing pages and docs. - [Relia vs Sentry](https://tryrelia.com/compare/sentry): Relia vs Sentry, checked against Sentry's own pricing and docs: free plans, paid plans, what each watches, uptime, on-call, and what the AI does with your code. - [Relia vs Datadog](https://tryrelia.com/compare/datadog): Relia vs Datadog, checked against Datadog's own price list and docs: free tier, per-host and per-volume prices, status pages, on-call and Bits AI. - [Relia vs Better Stack](https://tryrelia.com/compare/better-stack): Relia vs Better Stack, checked against Better Stack's own pricing and product pages: free plan, responder pricing, uptime, status pages, on-call and AI SRE. - [Relia vs New Relic](https://tryrelia.com/compare/new-relic): Relia vs New Relic, checked against New Relic's own pricing and docs: the 100 GB free tier, user and data pricing, alerts and paging, and New Relic AI. - [Relia vs Grafana Cloud](https://tryrelia.com/compare/grafana-cloud): Relia vs Grafana Cloud, checked against Grafana's own pricing and docs: the free tier, Pro platform fee and usage prices, IRM on-call, synthetic checks and Grafana Assistant. - [Relia vs PostHog](https://tryrelia.com/compare/posthog): Relia vs PostHog, checked against PostHog's own pricing and docs: free allowances, usage pricing, error tracking, logs, uptime and on-call, and PostHog's AI pull requests. - [Relia vs the DIY stack](https://tryrelia.com/compare/diy-stack): Sentry Team plus UptimeRobot Solo against one Relia plan: $35 vs $15 a month. - [Relia documentation](https://tryrelia.com/docs): Set up Relia for your stack, read incidents, fix problems and look up every command, setting and MCP tool. Every page is also plain Markdown for AI assistants. - [The Relia blog](https://tryrelia.com/blog): Practical guides to production errors, monitoring and incidents for teams without an SRE. - [Open-source tools](https://tryrelia.com/tool): Relia Analytics (plain-language questions over PostHog) and Relia Monitor (for Render and Railway). - [Privacy Policy](https://tryrelia.com/privacy): What personal data Relia collects, why, where it is stored, how long it is kept and how to delete it. - [Terms of Service](https://tryrelia.com/terms): Accounts, plans and billing, cancellation and refunds, acceptable use and liability. - [Cookie Policy](https://tryrelia.com/cookies): Every cookie and browser-storage item Relia uses. - [GDPR and data processing](https://tryrelia.com/gdpr): How Relia processes personal data for its customers, its subprocessors and breach notification. ## Links - [Start free](https://app.tryrelia.com/signup) - [Sign in](https://app.tryrelia.com/login) - [Live demo](https://app.tryrelia.com/demo): a real project, read-only, no sign-up - [Relia's own status page](https://status.tryrelia.com) - [relia-sdk on npm](https://www.npmjs.com/package/relia-sdk) - [relia-sdk on PyPI](https://pypi.org/project/relia-sdk/) - [MCP server address](https://devreliaapi.tryrelia.com/mcp) (for AI assistants: sign in from the tool, or use an account token) - [GitHub](https://github.com/tryrelia) - [X](https://x.com/tryrelia) - [LinkedIn](https://www.linkedin.com/company/tryreliaai)