Logging and Analytics for Non-Coders Who Vibe-Code

How to find out your app broke before a customer tells you, and how to measure whether anyone is using it, without turning your app into a surveillance product.

By · · 11 min read

Illustration for Logging and Analytics for Non-Coders Who Vibe-Code

There are two questions you cannot answer about your app right now, and both of them have the same answer: nobody told you.

The first is "is it broken for anyone?" The second is "is anyone actually using it?" An app built with Lovable, Bolt, v0 or Replit will happily run for weeks while being broken for a specific browser, or while being used by nobody at all, and give you no indication either way.

The Launch Readiness Checklist, which includes the error reporting, uptime and alerting items covered here
The Launch Readiness Checklist, which includes the error reporting, uptime and alerting items covered here

These are two different jobs with two different tools, and conflating them is why people end up with a dashboard full of numbers that never tells them anything broke.

Why you hear nothing when it breaks

When something fails in your app, the error appears in the visitor's own browser console. Not yours. Theirs. You will never see it.

It is worse than that, because production builds strip console output deliberately, for speed and to avoid leaking details. So the error is invisible on their machine too.

That leaves exactly one channel: a customer who is annoyed enough to find your contact form and describe what happened. Most people do not. They assume the app is broken, which it is, and leave. Your app can be failing for every Safari user for a fortnight and look perfectly healthy from where you are standing.

Error reporting: the one that matters

Error reporting means adding a small piece of code that catches failures in the visitor's browser and sends them somewhere you can read, along with which page it happened on and which browser.

Every builder can add this on request, and the free tiers of the common services are generous enough that a small app never pays. The setup is genuinely a few minutes.

The step people skip is the important one: make it fail on purpose. Deploy, then deliberately trigger an error on the live site and confirm the report arrives. Otherwise you have installed a smoke alarm without checking it has a battery, and you will trust a silence that means nothing.

What good looks like after a week: a handful of reports, most of them browser extensions interfering with your page, and occasionally one that is genuinely yours. Learning to tell those apart takes about a fortnight of looking.

Uptime: the cheapest insurance

Error reporting tells you when your app is broken for a visitor. It cannot tell you when your app is not there at all, because if the page never loads, your code never runs, and the thing that sends reports never runs either.

An uptime monitor is an outside service that loads your site every few minutes and tells you when it stops answering. Point it at two addresses: your home page, and one page that needs the database. The second one matters, because a database that has gone away leaves the home page looking perfect while the actual app is dead.

This catches the failures that are otherwise invisible for a whole day: an expired certificate, a failed deploy, a hosting account hitting a limit.

Where alerts should go

An alert sent somewhere you do not look is worse than no alert, because it feels like coverage while providing none.

Send them where you already get interrupted, which for most people is a phone notification or a chat app rather than email. Then decide two things: what is worth waking up for, and what can wait until morning. "The site is down" is the first category. "One user hit an error" is the second.

Be ruthless early. If you get alerted about things you do not act on, you will start ignoring the alerts within a week, and then the real one arrives and gets ignored too.

While you are there, set a spend cap or a billing alert on anything priced by usage, such as a model API, email sending or bandwidth. That is a different kind of alarm but the same principle: you want to find out from a notification, not from an invoice.

Analytics: the other question

Analytics answers "is anyone using this", which is a completely separate concern from "is it broken". You need both and they do not substitute for each other.

The trap is measuring everything and learning nothing. Page views tell you very little on their own. For a small app the useful set is short:

  • How many people arrive, and from where
  • How many complete the one action the app exists for
  • Where people stop, between arriving and completing

That third one is the whole value. Knowing 200 people reached your signup form and 12 finished it tells you something you can act on today. Knowing you had 4,000 page views does not.

Name the events after what the person did, not the component involved. signup_completed will still mean something in six months; button_3_clicked will not.

Doing this without becoming creepy

You are about to collect data about people, which brings obligations even for a hobby project.

Four rules that keep you clear. Do not put personal data in event names or error reports, which includes email addresses in page URLs. Choose an analytics tool that does not need a cookie banner if you would rather not have one, since several are built for exactly that. Say what you collect in your privacy policy, and make it true. And turn off session recording, or never turn it on: it captures what people type, which in most apps means capturing things you should not hold.

The useful test: if a user read your privacy policy and then saw your actual dashboard, would they feel misled? If yes, fix the dashboard rather than the wording.

The hour that gets you covered

  1. Add an error reporting service, deploy, and trigger an error on purpose to prove it arrives.
  2. Add an uptime monitor on the home page and one database-backed page.
  3. Route both to somewhere you actually read, and decide what is worth an interruption.
  4. Add analytics with three or four named events covering your main flow.
  5. Set a spend cap on anything billed by usage.
  6. Update your privacy policy to match what you just set up.

That is most of a working operations setup for an app that has no operations team, and it is the difference between finding out from a monitor and finding out from a customer.

Frequently asked questions

Why do I not see errors from my live app?

Errors happen in each visitor's browser, not on your machine, and production builds remove console output. Without an error-reporting service there is no path from their failure to your attention except a customer choosing to tell you, which most never do.

What is the difference between error tracking and analytics?

Error tracking reports failures: what broke, where and in which browser. Analytics reports behaviour: how many people arrived and how far they got. Neither answers the other's question, which is why an app usually needs both even at a very small scale.

Do I need both error reporting and an uptime monitor?

Yes, because they fail in opposite directions. Error reporting runs inside your app, so it reports nothing when the app does not load at all. An uptime monitor watches from outside and catches exactly that case, such as an expired certificate or a failed deploy.

Will analytics force me to show a cookie banner?

Not necessarily. Several analytics tools are built to work without cookies or personal identifiers and do not trigger a consent banner under most interpretations. The requirement follows from what you collect and store, not from having analytics at all.

Should I record user sessions to see what went wrong?

Generally no for an app with forms. Session recording captures what people type, which often means capturing passwords, personal details or client data you should not be holding. Error reports with the page and browser usually tell you enough without that exposure.

Sources and further reading

  • Core Web Vitals, Google. The field measurements worth monitoring alongside errors.
  • Lighthouse, Chrome for Developers. A local audit covering performance, accessibility and best practices.
  • Cookies and similar technologies, Information Commissioner's Office. When analytics storage requires consent.
  • Error Handling, OWASP. Keeping error output useful to you without leaking detail to visitors.

Browse all tools