Docs

Performance

How Sypnia measures page speed and API speed for real people, how percentiles are computed and shown, and how it names the element behind a slow page.

Applies to EngineCloud At launch

View as Markdown
On this page
  1. Page speed
  2. The element behind the number
  3. API speed and failures
  4. How percentiles are computed and shown
  5. When a page «got slower»
  6. Weekly suggestions
  7. Example: the search page
  8. Reference

This page is for anyone who wants to know which pages and API calls are slow for real people, and how far to trust each number. The measurements and the numbers are part of the open-source engine. Sypnia Cloud adds the performance pages of the app; on the engine you read the same numbers through the API, the CLI and MCP.

All numbers come from real visits to your app, not from a test run on one machine.

Page speed

For every page a person opens, the browser SDK reports four measurements.

MeasurementWhat it tells youGoodPoor
LCP, largest contentful paintHow long until the main content was visible.up to 2,500 msabove 4,000 ms
INP, interaction to next paintHow long the page took to react to a click, a tap or a key.up to 200 msabove 500 ms
CLS, cumulative layout shiftHow much the page jumped around while the person looked at it. A score, not a time.up to 0.1above 0.25
TTFB, time to first byteHow long your server took to start answering.up to 800 msabove 1,800 ms

Between «good» and «poor» a value is rated «needs improvement». These are the public Web Vitals thresholds.

Rules of measurement:

  • LCP and TTFB belong to the page where the browser loaded the document. Later pages reached by in-app navigation have none.
  • INP and CLS are measured for each page, including pages reached by in-app navigation. A page’s INP is its slowest interaction. A page’s CLS is the sum of its shifts.
  • Values that cannot be real are dropped: an LCP or TTFB above 120 seconds, an INP above 60 seconds, a CLS above 10.

The element behind the number

A slow LCP is only useful if you know what was slow. Each measurement names its element:

MeasurementElementExtra
LCPThe element that was the main content.Whether it is an image or text.
INPThe element the person interacted with.Whether it was a pointer or the keyboard.
CLSThe element that moved the most.
TTFBNone. It is about the server.

The element is named by a selector built from its test id, its id or a short path of tags. The selector never contains the page’s text. For each page, Sypnia lists the elements that most often stand behind each measurement, with their own numbers.

API speed and failures

For every call the page makes to your API, and every request your server handles, Sypnia keeps numbers for each method and route:

NumberMeaning
CallsHow many.
p50 and p95 durationAs the browser saw it, network included.
Server p95As the server measured it, when a server SDK or OpenTelemetry reports the request.
Server errors and no answerCalls that answered 500 or above, or got no answer at all.
RejectedAnswers from 400 to 499. Usually your app saying no on purpose. A 400 can also open a problem; see Problems.
Failure rateCalls that failed, divided by calls. A call has failed when it got no answer, answered 400, or answered 500 or above. Other answers from 401 to 499 are rejected calls, not failures.
Calls behind itThe average number of calls each request makes to a database or another service, and the average time it spends in them.

Routes are listed slowest first, by p95. A route is listed as failing when more than 2 % of its calls answered 500 or above, or nothing, with at least 50 calls in the period. That is also the rule of the «API failing» alert, which looks at the last hour.

How percentiles are computed and shown

Averages hide slow visits, so Sypnia shows percentiles.

  • p75 is the headline for pages: three visits out of four were this fast or faster. A page’s rating (good, needs improvement, poor) is the rating of its p75.
  • p50 and p95 are shown for API calls: the typical call, and the slow tail.

Percentiles are computed from histograms with fixed buckets, so any range of hours or days can be added together and still give a percentile. The buckets are:

ForBucket bounds
Durations, in ms50, 100, 200, 300, 500, 750, 1,000, 1,500, 2,000, 3,000, 5,000, 8,000, 12,000, 20,000
CLS0.01, 0.025, 0.05, 0.1, 0.15, 0.25, 0.4, 0.6, 1

This has three consequences, and Sypnia shows each of them instead of hiding it:

  1. A percentile is exact to its bucket, not to the millisecond. Inside a bucket the value is estimated in proportion to the samples. A p75 of 3,100 ms means «between 3,000 and 5,000 ms, close to the lower end».
  2. Above the last bound, the real value is unknown. A percentile that lands beyond 20,000 ms, or beyond a CLS of 1, is shown as «more than 20 s», and the data carries a flag that says so.
  3. A percentile comes with its number of samples. A p75 from 12 visits and one from 12,000 are not worth the same, so the count is always next to the number. Lists of the slowest pages, and of pages that got slower, leave out pages with fewer than 50 views in the period.

Numbers can be read for one device class: mobile, tablet or desktop. They are complete within 10 minutes.

When a page «got slower»

Sypnia says a page got slower when both are true:

  • its p75 LCP over the last 24 hours is 30 % or more above its p75 over the 7 days before, and
  • the page had at least 50 views in each of the two periods.

When that happens Sypnia creates an alert, once, and the daily summary reports it. Both numbers can be changed in the project’s alert rules. See Alerts and the daily summary.

Weekly suggestions

Once a week, on Monday at 07:00 UTC, the agent reads the numbers of the week that ended, the elements behind them and the click data, and proposes improvements to performance and to how the app is used, each with its evidence: the page, the number, the element. Some suggestions come from fixed rules, such as an INP above 500 ms at p75 or more than 3 rage clicks for each 100 views, and need no model. The others are written by a model. See How the analysis works.

The Sypnia engine and Sypnia Cloud compared
Sypnia engineOpen source, self-hostedSypnia CloudPaid service, with a free tier
Measurements, percentiles, elementsYes. Read them through the API, the CLI or MCP.Yes, with the performance pages of the app.
Weekly suggestionsThose from fixed rules, always. Those written by a model, with your own model key.Included.
When a page gets slowerAn alert is recorded and sent to your webhooks.An alert by e-mail and in the app, and a line in the daily summary.

Example: the search page

The shop’s daily summary says: «The search page got slower: 3.1 seconds to load, it was 1.9.»

Behind that sentence:

Previous 7 daysYesterday
Route/search/search
p75 LCP1,900 ms (good)3,100 ms (needs improvement)
Views1,804262

3,100 is 63 % above 1,900, and both periods have more than 50 views, so the page «got slower». The element behind the LCP is the first product image, an image, in most of yesterday’s visits. That points at the picture, not at the server: TTFB did not change.

Reference

The fields and filters are in the API reference. What the browser SDK measures and how to turn it off is in Browser.

Sections

Start hereWhat Sypnia is, how it works, what is open source and what is the paid cloud, and the two ways to get your first problem in plain words.ConceptsThe ten ideas Sypnia is made of, each defined precisely, from a project and its keys to problems, traces and alerts.SDKsHow your app sends data to Sypnia. One SDK for the browser, one for Node, one for Next.js, and the OpenTelemetry intake for every other backend.The agentHow Sypnia analyses a problem, what it writes, what it sends to a model and what it never does.MCP and skillsConnect your coding agent to Sypnia so it can ask what is failing in production, read what it needs to fix it, and set Sypnia up for you.API referenceThe Sypnia HTTP API: one API for the open-source engine and for Sypnia Cloud, with every endpoint, parameter, response and error.CLI referenceThe sypnia command: how to install it, the variables it reads, what its exit codes mean, and where each command is documented.Self-hostingWhat you run when you host the Sypnia engine yourself, what you need, what it costs, and what you do not get compared with Sypnia Cloud.How the engine is builtThe whole Sypnia engine on one page, from a click in your app to the sentence your coding agent reads, with the design rules and the code that holds them.Sypnia CloudHow the paid service works, from organizations and roles to plans, limits, billing, where your data lives, the GitHub App and support.Privacy and securityWhat Sypnia collects from your app and its users, what it never collects, how masking works, how to delete data, and how the service is protected.LicensingWhich licence covers each part of Sypnia, what you may do with it, how the name may be used, and the terms of a contribution.GuidesStep-by-step recipes for the common ways to use Sypnia, from apps made with AI builders and Next.js on Vercel to Supabase, source maps in CI, alert e-mails from your own engine, and moving from Sentry.ReferenceThe pages you look things up in, from the event schema and the glossary to what is planned, the changelog and the common questions.
↑↓ to move↵ to openEsc to close