# Alerts and the daily summary

> What creates an alert, what an alert contains, how it reaches you on the engine and on Sypnia Cloud, and what the daily summary says and when.

Applies to: the Sypnia engine (open source, self-hosted) and Sypnia Cloud (paid service). Status: at launch.  
Source: https://docs.sypnia.com/concepts/alerts-and-daily-summary/

This page is for anyone who wants to know when Sypnia will interrupt them, and when it will wait. Alerts are created by the open-source engine. How they reach a person is where the engine and Sypnia Cloud differ most, so this page shows both side by side. The daily summary is part of Sypnia Cloud.

The idea is simple: **an alert when it cannot wait, and one short message a day for everything else.**

## What creates an alert

An alert is a record that says something needs a person. There are nine kinds, one rule for each. The set is fixed: you can switch a rule on or off, choose its environments and tune its numbers, but not add kinds.

| Alert                 | Created when                                                                              | Numbers you can tune (default)                     |
| --------------------- | ----------------------------------------------------------------------------------------- | -------------------------------------------------- |
| **New problem**       | A problem is seen for the first time.                                                     | None                                               |
| **Problem came back** | A resolved problem happens again and reopens.                                             | None                                               |
| **Problem growing**   | An open problem reaches twice the people it had at its last alert, and at least 5 people. | The factor (2) and the fewest people (5)           |
| **App down**          | An uptime check fails twice in a row.                                                     | The number of failures (2)                         |
| **App up again**      | A check that was down answers again.                                                      | None                                               |
| **Page got slower**   | A page's p75 LCP over the last 24 hours grew against the 7 days before.                   | The increase (30 %) and the fewest views (50)      |
| **API failing**       | An API route answers `500` or above, or nothing, too often over the last hour.            | The share of calls (2 %) and the fewest calls (50) |
| **Usage limit**       | The project reaches a share of a usage limit.                                             | The shares (80 % and 100 %)                        |
| **Engine failing**    | Processing has not caught up for 30 minutes, or deliveries to a webhook keep failing.     | None                                               |

All nine are on for a new project, for the `production` environment only. Your own testing does not wake you up.

What never creates an alert:

- A problem you **ignored**.
- More occurrences of a problem that is already open and not growing. One problem is one alert, not one for each person it hits.
- A rage click, a dead click or a form failure. They wait for the daily summary and the weekly suggestions.
- A check that is still down, or a page that is still slow. Each alerts once, when it changes.

Anyone can **acknowledge** an alert. That records who saw it and when, and changes nothing else: the problem or the check behind it keeps its status.

The rules, their fields and how to change them are in the [API reference](https://docs.sypnia.com/api/webhooks).

## How fast

- A new problem can alert within 2 minutes of its first event.
- An outage alerts about 2 minutes after your app stops answering.
- The alert for a problem waits for the agent's sentence, but never beyond those 2 minutes. If the analysis is not ready, or the agent is off, the alert goes out with the problem's technical title, and the sentence appears on the problem when it is written.

## What an alert contains

Every alert carries:

| Part         | Content                                                                                                                                                           |
| ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Kind         | One of the nine above.                                                                                                                                            |
| Where        | The project and the environment.                                                                                                                                  |
| When         | The time it was created.                                                                                                                                          |
| Title        | For a problem, the sentence in plain words, or the technical title if the agent has not written one. For the others, what happened to which check, page or route. |
| Link         | To the problem, check, page or route: in the app on Sypnia Cloud, in your Console on a self-hosted engine.                                                        |
| Acknowledged | Who saw it and when, once someone has.                                                                                                                            |

An alert about a problem adds:

- **who it hit so far**: people and sessions at the moment of the alert,
- **since when**: the first occurrence.

The e-mail of Sypnia Cloud also says which release it came with, if known, **what to do** when the analysis is ready, and links to **one session with a replay** when there is one.

An alert about uptime adds the address, since when, the reason, and for «up again» how long the outage lasted. An alert about a page or a route adds the two numbers it compared.

An alert never contains what a person typed, a stack trace's full text, or anything masked.

## How an alert reaches you

|                 | Sypnia engine (open source, self-hosted)                                                                                       | Sypnia Cloud (paid service, with a free tier)                           |
| --------------- | ------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------- |
| Recorded        | Yes. Every alert is kept and can be listed through the API, the CLI and MCP.                                                   | Yes. The same.                                                          |
| Shown           | In the Console.                                                                                                                | Inside the app, marked until someone acknowledges it.                   |
| E-mail          | No. The default deployment has no e-mail sender.                                                                               | Yes, to the members of the organization. Usage alerts go to its owners. |
| Webhook         | Yes. Each alert is sent to the webhooks you registered, signed, and retried for about 21 hours if your server does not answer. | Yes. The same.                                                          |
| WhatsApp, Slack | No.                                                                                                                            | No.                                                                     |

### On a self-hosted engine **\[Engine]**

The engine's job ends at recording the alert and calling your webhook. Getting it to a person is a piece you choose, and the docs give the recipes:

**A piece you choose: Alert delivery.** Gets an alert from the engine to a person.

- **Default deployment:** None. Alerts are recorded, shown in the Console and sent to a webhook if you set one.
- **Sypnia Cloud uses:** E-mail through Amazon SES, and alerts inside the app.

Until you connect one, alerts are not lost: they are in the Console and the API, and your coding agent can ask for them through MCP.

### On Sypnia Cloud **\[Cloud]**

- **E-mail.** Each member of the organization receives alert e-mails for its projects. Each member can switch them off for a project in their own settings. Alerts about a usage limit go to the organization's owners.
- **Inside the app.** Alerts are listed for everyone in the organization, newest first.
- **Webhooks**, if you registered any.

## The daily summary **\[Cloud]**

The daily summary is one e-mail a day that tells you how your app did the day before, in plain words. It is also shown in the app.

|                |                                                                                                                               |
| -------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| Sent           | Every day at 08:00, in the project's time zone.                                                                               |
| Covers         | The previous calendar day in that time zone, in the `production` environment.                                                 |
| To             | Each member of the organization, one e-mail for each project. A member can switch it off for a project in their own settings. |
| On a quiet day | It is still sent, and says that nothing new happened.                                                                         |

In this order:

1. **Problems.** Those that were new, came back or grew that day, most people first: the sentence, how many people, and whether a pull request is waiting. At most 5, then «and 2 more».
2. **Still open.** One line with the number of older open problems that hit people that day.
3. **Got slower, or failing.** Pages that got slower and API routes that are failing, by the same rules as their alerts. At most 3 of each. The rules are in [Performance](https://docs.sypnia.com/concepts/performance).
4. **Frustration.** Elements that at least 3 people rage-clicked or dead-clicked. At most 3.
5. **Uptime.** «Your app answered all day», or each outage with its length. Left out if the project has no uptime check.
6. **People.** How many people used the app, and in how many sessions.
7. **Usage.** Only when the project is at 80 % or more of a plan limit.

A project with no events that day still gets its summary, with one line saying so.

The summary is built from numbers the engine already has and from the sentences the agent already wrote. It contains nothing that is not also in the app.

### And on a self-hosted engine?

The engine does not write a daily summary. The same facts are one request away: `GET /v1/summary` answers «what is failing now?» with the open problems that matter most, the checks that are down and the pages that got slower, and your coding agent gets the same answer from the MCP tool `health`. See the [API reference](https://docs.sypnia.com/api/overview-and-authentication) and the [MCP tools](https://docs.sypnia.com/mcp/tools-reference).

## Example: the shop

**09:14, an alert by e-mail** (Sypnia Cloud):

```text
New problem in shop (production)

1 person tried to pay and could not. The Pay button does nothing
since yesterday's change.

Who it hit     1 person, 1 session, so far
Since when     Today 09:12. First seen in release 4f2a91c,
               deployed yesterday at 18:40
What to do     The checkout still reads the cart's old field name.
               Point it at the new one.

Open the problem · Watch the session
```

By the afternoon three people have hit it. That does not send three alerts: it is the same problem, already open, and 3 people is not yet «growing», which starts at 5.

**The next morning at 08:00, the daily summary:**

```text
shop · Good morning. Here is yesterday.

  ●  1 new problem: 3 people tried to pay and could not, since
     yesterday's change. A pull request is waiting for you.
  ●  The search page got slower: 3.1 seconds to load, it was 1.9.
  ●  Your app answered all day. 412 people used it.
```

On a self-hosted engine, the same morning: the same alert is in the Console and was sent to the webhook. If a function on that webhook sends e-mail, you got the e-mail too.

## Reference

Alert fields, alert rules and webhooks: the [API reference](https://docs.sypnia.com/api/webhooks). Sending alert e-mails yourself: [Sending alert e-mails from a self-hosted engine](https://docs.sypnia.com/guides/alert-emails-self-hosted).
