Unreal Ops Platform
Unreal Ops Monitor
Crashes, uptime, and the job that was supposed to run.
An unhandled exception in a shipped app is usually invisible to you. The user force quits, maybe reinstalls, and never files a report. Monitor is the piece of your stack whose only job is to notice, and then to hand you a stack trace you can actually read. It watches the other kind of failure as well, the kind that happens while none of your code is running.
Monitor runs at monitor.unrealops.ai and takes real crashes from Flutter and Next.js apps, this site included. The free plan is open and the screen after signup has your DSN on it. Billing is the piece that does not exist, so the prices further down are published rather than charged: there is no checkout, and nothing here has a customer.
The failures that happen while nothing is running
A crash report needs your code to be running to exist. Much of what actually takes a small product off the air does not: the site stops answering, a certificate lapses on a Sunday, a domain nobody remembered to renew expires, the nightly backup quietly stops firing. Monitor watches all four, and none of them needs an SDK in anything.
It says what that is worth, too. An uptime check runs every five minutes and is called down after three consecutive failures, so an outage is noticed roughly ten to fifteen minutes in. That sentence is on the screen where you set the check up, rather than in a footnote, because it is the honest description of what a five minute check can promise.
Run it beside Sentry before you trust it
Nobody should move their crash reporting to a service they have not watched work. Point your app at Monitor, paste your existing Sentry DSN into the upstream field, and both backends receive the same traffic from the same builds.
Compare for as long as you like, on your own crashes rather than on a demo. Clearing the field stops the forwarding on the next event, with no rebuild and no redeploy. If Monitor turns out to be wrong for you, Sentry never stopped working and you change one string to go back.
Caps that stop instead of billing you
A crash loop in one app produces events as fast as the device can restart. Everywhere else that is an unbounded bill arriving on a Tuesday, which is the failure mode that teaches people to turn monitoring off. Monitor answers a runaway with a refusal.
A per minute ceiling catches the loop within the minute and a monthly ceiling catches the slow bleed. Over either one, ingest refuses in the way the SDK already understands, the client stops sending, and every refusal is counted against a reason on your usage screen. There is no overage line on any plan, because there is no overage.
What it does not do
No session replay and no profiling. Both were assessed and neither ships. A stack trace describes a program; a replay records your user's screen, and that person has no relationship with us at all. If you need replay, keep a Sentry DSN in the upstream field above and it carries on being recorded there. For the cheaper half of what replay is used for, which is what the user was doing just before it broke, breadcrumbs are already on every event.
Nothing here will wake anybody up. Email, Slack and signed webhooks all work, off one shared decision with cooldowns and ceilings so a crash loop costs one message rather than four hundred. What does not exist is an on call rota or an escalation policy, so whatever reaches a person at three in the morning is still whatever you already use.
Which platforms work today
- FlutterAvailable
Verified end to end by doing it rather than by reading code: real envelopes grouped at the live endpoint, symbols uploaded at build time and traces returned readable, release health computed per release, and an alert email actually delivered.
- Next.jsAvailable
Verified end to end on this site, browser and server both. A deliberate crash thrown from the deployed, minified bundle came back through Monitor's API naming the exact file and line in this repository. Server source maps are a per project setting and are off by default, because they spend your own pooled symbol allowance.
- React NativeComing Soon
Planned, with no code written. It is deliberately not a blocker for anything above it.
- ExpoComing Soon
Planned alongside React Native, with no code written.
This table is the whole list. A Sentry SDK for some other platform can send an envelope this ingest would accept, and that is not the same thing as support, so native iOS, native Android and Node are missing from it on purpose. Uptime and heartbeat checks are the exception: they watch a url rather than an app, so they work against anything that answers a request or can run curl.
What Monitor does
Everything here runs today. Where a capability needs an SDK in your app it works on the platforms marked Available above. Where it only needs a url, it does not care what you built the thing in.
Readable stack traces
Symbols uploaded at build time, so a production trace comes back with your file names and line numbers instead of obfuscated hex. Included on every tier, the free one included.
Issue grouping
Identical faults collapse into one issue with a count, a first seen, a last seen and the releases affected. The grouping rule and its inputs are shown, so a surprising group can be explained rather than argued with.
Release health
Crash free sessions and crash free users per release, compared against the release it replaced, so a bad build is obvious to you before it is obvious in the reviews.
Breadcrumbs and context
The navigation, network calls and log lines that preceded the fault, timed as an offset from the crash, plus device, OS, locale and app version on every event.
Uptime, with the certificate and the domain
A check every five minutes, called down after three consecutive failures. The certificate's expiry is read off the same handshake. The domain's expiry comes from the registry, and a registry that will not answer is reported as unanswered rather than guessed.
Cron and heartbeat checks
A bare curl on the end of a crontab line, with no SDK and nothing to sign. Grace periods mean a job running late is a state on the screen rather than an email, and the last twenty runs are kept so you can see whether last night was unusual.
Status pages, public or private
Components driven by the checks above, incidents opened automatically, maintenance windows that suppress what they cover, and email subscribers who confirm first. A public page carries no identifier from inside the platform.
Alerts to email, Slack and signed webhooks
One notification through one decision the three channels share, with per issue cooldowns and hourly ceilings. A webhook is signed over the timestamp and the body together, so a captured delivery cannot be replayed at you next week.
Performance traces and structured logs
Transactions with the span tree underneath them, and log lines searchable beside the release and trace they belong to. Both spend the same pooled allowance crashes do, capped so a month of tracing can never leave you with no crash reports. Log lines are scrubbed before anything is written.
Who it is for
- Solo developers and small teams shipping apps to the app stores.
- Agencies and contractors maintaining apps they built for somebody else.
- Anyone who currently finds out about a crash from a one star review, or about an outage from a customer.
- Anyone who has turned monitoring off because the bill stopped being predictable.
Built on open source
Monitor uses the open source Sentry SDKs, unmodified, pointed at ingestion we run ourselves. Those SDKs are mature, they are maintained by people who do nothing else, and they are not ours to quietly break. Nothing from the commercial Sentry backend is involved.
The practical consequence is that adopting Monitor, on a platform in the table above, is a change to one DSN string. No rewrite, no shim, no second package fighting the first one for the error handler.
What it will cost
Published before there is any way to pay them, because a price argued with early is cheaper to change than one defended after launch. The free plan is open and real. The paid ones are prices rather than purchases.
Developer
Free
Enough of the real product to judge it, including the part that makes it worth having.
- 1 project
- 5,000 pooled events per month
- 7 day retention
- Symbolication included
- 5 MB of symbols, about one release
- Email alerts
- 1 user
Open at monitor.unrealops.ai. One form, and the next screen has your DSN on it.
Solo
$13per month
One person or one small team shipping a handful of things.
- 3 projects
- 50,000 pooled events per month
- 30 day retention
- Unlimited teammates
- Release health
- 15 MB of symbols, about three releases
- Standard alerts
Not purchasable. Billing is not built.
Studio
$39per month
A studio or agency carrying other people's apps as well as its own.
- 10 projects
- 250,000 pooled events per month
- 90 day retention
- 50 MB of symbols, about ten releases
- Slack and webhooks
- Advanced alerts
- Priority support
Not purchasable. Billing is not built.
Agency
About $79per month, later
For when ten projects stops being enough. It comes after launch.
- More projects and a larger pooled quota
- Shape still open, which is why the price is approximate
Not a tier you can pick. It is what comes next, not what exists.
The plan stops. It does not bill you.
At your monthly limit, ingest refuses further events in the way the SDK understands, the client stops sending, and the refusals are counted and shown to you. Nothing keeps accepting events and settles up later, so there is no overage rate to look up and no invoice you did not expect. If you would rather be billed than capped, Monitor is the wrong product.
Quotas are pooled across your organization
The event allowance on every tier is organization wide, not per project. A quiet project does not waste an allocation it never used, and a noisy one does not need its own.
Symbolication is on the free tier on purpose
Readable traces are the product, not the upsell. Putting them behind the first paid tier would mean a free account never sees what Monitor actually does.
Symbol storage keeps your newest releases
When the allowance is full, uploading a new release deletes the oldest release's symbols to make room. The build you just shipped always resolves, and an older one stops. A smaller tier keeps fewer releases of history, not less of the product.
Nothing on this page can be bought. Billing is the last unbuilt piece: the free plan is open and works, and paying for a bigger one is what is still missing, so every account is on the free plan whichever tier it picked. These prices are published early so you can tell us they are wrong while changing them is still free.
The rest of the platform
Monitor shares its account and its project structure with everything else Unreal Ops builds. The full build order is on the platform overview.
No signup fee, no card
Point one app at it and see.
Monitor has its own site, and it is the product rather than a description of one. Creating an account takes one form and ends on a screen with your DSN on it.
Tell us what you ship and roughly how much of it, and we will tell you honestly whether it is ready for you yet.
Every product here is built by Unreal Ops. Nothing on this site can be bought yet, and nothing has a customer. When that changes, these pages change with it.
Monitor, in its own words: what it stores and what it drops, how long it keeps it, and who answers.