NoCodeLab.ai

ResourcesSilent Failures

Your vibe-coded app is up.

That doesn't mean it's working.

In July one person emailed to say she could not register for our live session. Chasing that single complaint uncovered four unrelated broken pipelines on nocodelab.ai. Every one was silent, every one had been running for weeks, and the site was up throughout. Pages loaded, forms submitted, endpoints returned success. This is what we found, why uptime monitoring would have reported green the entire time, and how to build the kind of monitoring that would have caught it on day one.

BySara SimeoneFounder, NoCodeLab

One real production site, built with AI tools. Audited July 2026.

8 weeks
A reminder email that never sent
11 days
Real signups rejected as bots
0
Errors raised by any of it

Nothing errored. That's why nobody noticed.

Four unrelated failures, found in one morning by investigating a single complaint. None of them threw an error. That is why they lasted.

8 weeks

The day-before reminder had never sent a single email

The hourly job had returned an authentication error on every run since the day it launched. Nobody saw it, because the error went to a log nobody reads and the one-hour reminder kept working perfectly. Attendance looked slightly soft. It never occurred to us that half the reminder system had never run at all.

11 days

The anti-spam trap was turning real people away

A hidden form field, the standard trick for catching bots, was being helpfully filled in by password managers. Anyone using one was classified as a bot and rejected. Newsletter signups fell to zero and read as an unremarkable quiet fortnight in midsummer.

since feature launched

Event registrants never reached the mailing list

Dozens of people ticked the box to hear about future sessions. None of them arrived. Nothing errored, because nothing ever attempted the sync. The website and the email platform simply disagreed about whose job it was, and an absence throws no exception.

since feature launched

Registering twice produced a success screen and no email

The confirmation email fired only on a first registration. Anyone who signed up again for a later session saw a cheerful "You're in" and received nothing at all. From their side it looked like we had lost them.

A fifth turned up the following day. A substantial share of conversations with our AI diagnostic were ending without ever producing a recommendation, so those visitors generated no lead and no follow-up. Not a crash, not an error, just people quietly leaving mid-conversation. Invisible in every report we had.

The pattern is the point. Every one of these was a pipeline that produced nothing while reporting success, and in each case the surface a visitor could see behaved perfectly. This is the characteristic failure mode of AI-built apps: the code is generated feature by feature against a visible acceptance test, and the test is always "does the screen do the right thing", never "did the consequence actually occur three systems later".

Uptime monitoring would have shown green throughout

The instinctive response to an outage is to buy uptime monitoring. It would not have caught a single one of these.

An uptime service pings your site every few minutes and alerts you when it stops responding. That is a real failure mode and worth covering. It is also not what happened here. The site was up for all eight weeks. Pages rendered, forms accepted input, and the endpoints returned ordinary-looking success responses. A prober would have recorded perfect availability while the business quietly took no bookings.

FailureCaught by uptime?What actually catches it
Reminder job failing to authenticateOnly if you configured it to watch that jobChecking the scheduled job's result, not the page
Signups rejected as spamNoNoticing the absence of signups
Mailing list never syncedNoReconciling the two systems against each other
Repeat registration sent nothingNoChecking records for a missing send

The distinction worth carrying away is a single question. Uptime monitoring asks "is it responding?" Outcome monitoring asks "did the thing that should have happened, happen?" Only the second question would have found any of this. So we bought no uptime service. What we built instead queries our own records and compares them against what ought to be true.

Write the sentence, and you have the check

Before writing any code, write sentences. This is the whole method, and it works on a napkin.

List every pipeline in your app. A pipeline is anything where one thing happening is supposed to cause another thing to happen: a form submission that triggers an email, a signup that syncs to a mailing list, a nightly job that produces a report. For each one, write a single sentence in this shape.

The template
When X happens, Y must exist within Z.

That sentence is the check. Once it is written, turning it into a database query is mechanical, and it is a task an AI coding assistant does well because you have removed every ambiguity. Here are four of ours, in the form we wrote them before any code existed.

Our pipelines, as sentences
When someone registers for an event,
  a confirmation email record must exist within 15 minutes.

When someone ticks the consent box,
  they must appear in the mailing list within 1 hour.

When a session is less than 23 hours away,
  every registrant must have a reminder logged.

When a scheduled job is due,
  a successful run must exist within 25 hours.

Notice what the exercise forces. You cannot write the sentence without deciding what "done" looks like and where the evidence of it lives. Half of our failures existed because nobody had ever articulated the second half of the sentence, and a consequence nobody named is a consequence nobody checks.

If you do nothing else from this guide, do this. Ten sentences on a page will tell you more about where your app is quietly broken than any dashboard you can buy.

The six checks that catch almost everything

Our health check runs fourteen queries, but they are only six kinds of question. These six cover most of what breaks in an AI-built app.

1. Did the scheduled job run at all?

Every recurring job should have left a completed run behind it in the last day. This is the cheapest check to write and it catches the scheduler being paused, the database sleeping, or a job silently dropped in a redeploy.

2. Did it come back with an error?

Running is not succeeding. Our reminder job ran faithfully every hour for eight weeks and returned an authentication failure every single time. Check the response status of your background calls, not just their existence. This one check would have caught our worst failure on day one.

3. Has the whole thing gone silent?

An error check finds bad results. It cannot find the absence of results. If signups normally arrive every day or two and none has arrived in four, something is broken even though nothing anywhere has errored. This is the check that would have found our spam trap eating real people.

4. Is anything stuck waiting?

For every pipeline with a handoff, look for records that entered and never left. Anyone registered for more than fifteen minutes without a confirmation logged against them is evidence of a break, and it is specific enough to act on immediately. This is the sentence from section 03, turned into one query.

5. Do two systems still agree with each other?

The most dangerous failures produce no error anywhere, because nothing was ever attempted. Dozens of people consented and never reached our mailing list, and the only thing that can find that is a reconciliation: count everyone who consented, count everyone actually on the list, compare. Wherever your app hands data to another platform, something has to periodically check that the other platform agrees.

6. Does everything you depend on still exist?

We list every AI feature on the site with the model behind it, and verify each one against the vendor's live catalogue daily. Models get retired, APIs get versioned out, free tiers get withdrawn. Without this check the first you hear of it is a visitor hitting an error at the exact moment they were about to convert. The same logic applies to any third-party service you cannot control.

Thresholds you won't learn to ignore

A monitor that cries wolf is worse than no monitor, because it trains you to skim past the email that mattered.

The temptation is to pick round numbers by instinct. Don't. For each surface, query the gaps between records across the last four months, find the longest gap that fell in a stretch you know was healthy, and set the alert comfortably beyond it. We re-derived every one of ours this way rather than guessing, and several came out nowhere near where instinct had put them.

The shape of the answer is the transferable part. Whatever your volumes, it tends to land like this.

If the surface seesA healthy quiet spell isSet the alert aroundTier it as
Several a dayA few hoursSame dayCritical
A few a weekTwo to three daysFour to five daysWarning
A few a monthOne to two weeksThree weeksInfo only

The rule underneath it is roughly one and a half times the longest healthy gap, rounded up to a number you would actually act on. The bottom row is the one people get wrong. On a surface that only sees a handful of events a month, a fortnight of silence genuinely means nothing, and alarming on it would train you to stop reading the email entirely. Report it as context instead, where a human can notice a pattern over time. That is the right home for a weak signal.

If you have less than four months of history, use what you have and revisit it. The threshold is not sacred. What matters is that it came from evidence, because a threshold you guessed is a threshold you will not trust at 7am when it turns red.

Rules that keep a monitor worth reading

Six design rules, each of which we got wrong at least once first.

Send the email every day, good news or bad

A monitor that only speaks when something is wrong is indistinguishable from one that has silently died, which is the exact failure you are trying to prevent. Daily arrival is itself the proof of life.

Put the verdict in the subject line

On a normal day the email should never need opening. Ours reads "NCL health: all green" and the judgement happens in the inbox list in about a second. Anything that costs more attention than that will eventually stop getting it.

Have something watch the watchman

Nothing inside a system can report its own death. Ping an external dead man's switch only when a run completes cleanly, so that a crash, a failed email or a stopped scheduler all withhold the signal and something outside complains for you.

Never cry wolf

Thresholds from real history, low-volume surfaces reported rather than alarmed, and known historical oddities excluded on purpose. We carved out one batch of old records specifically so it could not generate a permanent false alarm.

Reconcile, don't just watch for errors

The worst failures produce no error at all, because nothing was ever attempted. Two systems quietly disagreeing is only ever visible to something that compares them.

Don't monitor data you cannot trust

We rejected two obvious-looking checks because the fields behind them are not reliably written, so they would have been permanently red. A check that is always failing is not a check, it is training in ignoring the report.

Build it this afternoon

Nothing here needs a platform or a budget. Ours is one scheduled function, a set of queries and an email.

  1. 1

    Write the sentences first

    One line per pipeline, in the "when X happens, Y must exist within Z" form. Do this before you open an editor. It is the only part that requires you rather than the AI, because only you know what your app is supposed to accomplish.

  2. 2

    Derive the thresholds from your own history

    For each "has it gone silent" check, query the gaps between records over the last 120 days and take the longest healthy one. Tier anything below roughly three events a week as informational rather than alarming.

  3. 3

    Build one scheduled function that emails a verdict

    One job, running daily, that executes each query, classifies the result as critical, warning or informational, and emails the summary with the overall verdict in the subject line. Give the prompt below to your AI assistant along with your sentences.

  4. 4

    Add the dead man's switch, and configure it

    Sign up for a free cron-monitoring service, ping it as the last step of a clean run, and then set the expected period and grace window. That last part matters: an unconfigured switch will happily accept your daily signal and never complain when it stops, which disables precisely the half of the design that catches the monitor's own death.

  5. 5

    Re-derive the thresholds quarterly

    As traffic grows a four-day silence threshold becomes far too slack. Put it in the calendar, because this is the maintenance step everyone skips and it is what quietly turns a good monitor back into a decorative one.

Copy into your AI coding assistant
Build me a daily health check for this app.

Create one scheduled job that runs at a fixed time each day and:

1. Runs a set of SQL checks against our own database.
2. Classifies each result as CRITICAL, WARNING or INFO.
3. Emails me the results every day, pass or fail, with the
   overall verdict in the subject line.
4. Pings an external dead-man's-switch URL only if the whole
   run completed and the email was sent successfully.

The checks are:
[paste your "when X happens, Y must exist within Z" sentences]

Rules:
- Report INFO checks in the body but never let them change
  the subject line verdict.
- Never invent thresholds. Ask me for each one.
- If a check depends on a field that may not be reliably
  written, tell me instead of adding the check.

What to leave out on purpose

Stating the limits is part of the control. A daily check like this does not cover visual or layout correctness, because it reads data rather than pixels. It does not catch anything that breaks and recovers inside 24 hours. It will usually tell you that something failed without telling you which pipeline, so diagnosis stays manual.

All of which is fine. The gap between "we found out in weeks, from a customer" and "we found out the next morning, from ourselves" is the entire value. Closing the last few hours costs far more than it returns at this size, and pretending otherwise is how monitoring projects stall before they ship anything.

Questions we hear

My app is up but the forms aren't working. Why didn't monitoring catch it?

Because almost all monitoring watches whether your site responds, not whether it does its job. A form that accepts a submission and then quietly drops it returns exactly the same success response as one that works. The server is healthy, the page renders, the status code is 200. Nothing in that picture is wrong, which is precisely why nobody notices for weeks. Catching it needs a check that looks at your own records and asks whether the thing that should have happened actually happened.

What is outcome monitoring?

Uptime monitoring asks "is it responding?" Outcome monitoring asks "did the thing that should have happened, happen?" In practice that means a daily job that queries your own database and compares it against what ought to be true: every registration from the last hour has a confirmation email logged against it, every person who ticked the consent box appears in the mailing list, every scheduled job ran and returned a success. It watches results rather than requests.

Is uptime monitoring enough for a small site?

It covers a real failure mode, so it is not worthless, but on its own it misses the failures that actually cost you money. When we audited our own site we found four broken pipelines, and an uptime prober would have reported green through every one of them, for eight straight weeks. Uptime tells you the lights are on. It cannot tell you the shop took no orders.

Do I need to buy a monitoring service?

For outcome monitoring, no. The checks have to query your own database, so nothing off the shelf knows what to look for. Ours is a single scheduled function that runs a set of SQL queries once a day and emails the verdict, and it took an afternoon to build with an AI coding assistant. The one thing worth using an external service for is the dead man's switch, because that has to live outside your system to be useful, and free tiers cover it.

What is a dead man's switch in monitoring?

It is an external service that expects a signal from you on a schedule and raises the alarm when the signal stops. Your health check pings it only after a run completes cleanly. If the checks crash, the email fails, or the scheduler stops firing, the ping is withheld and the external service complains on your behalf. It exists because nothing inside a system can report its own death, and a monitor that has quietly died looks identical to a week where nothing went wrong.

How do I stop monitoring alerts becoming noise I ignore?

Derive every threshold from your own history instead of guessing. Query the last few months, find the longest gap that occurred during a period you know was healthy, and set the alert comfortably beyond it. Then tier the results: low-volume surfaces get reported but never alarm, because on a surface that sees only a handful of events a month a quiet fortnight genuinely means nothing. A monitor that cries wolf is worse than no monitor, because it teaches you to skim past the one email that mattered.

Three doors. Pick the one that fits where you are.

Ready to put this to work? Pick where you start.

Lab Live

A free masterclass every first Thursday at 12:30pm UK. Sixty minutes. Sara demos one thing she has built that month, walks through how it works, and answers questions. No slides. No selling.

Register, free

The Soloist

8 sessions, built entirely around your role and your tools. By session three you will be saving a day a week. By session eight you have built one working system and know how to build the next.

Explore The Soloist

The Studio

6 months, your whole team. We turn what your business knows into AI powered IP your competitors cannot replicate.

Explore The Studio
Book a free strategy call

30 minutes. No pitch. We will tell you honestly which door is right, or if the answer is none of them yet.