Monitoring and Iterating After Launch

Intermediate · 8 min

Setting up error tracking, session replay, and performance monitoring so you learn about problems from your tools, not from a user's complaint.

Before thisConnecting a Database

Sentry · 8 min

Monitoring and Iterating After Launch

The player loads from youtube-nocookie.com when you press play. Nothing reaches YouTube before that.

Taught by SentryReport a problem with this video
Not started
Set this lesson's status

What you'll learn

  • Shipping isn't the end of the work — it's the point where you switch from building blind to building with real signal, and monitoring is what supplies that signal.
  • Error tracking captures exceptions with a stack trace and the surrounding context automatically, which beats finding out about a bug from a user's vague bug report or a one-star review.
  • Session replay lets you watch what a user actually did leading up to a failure, closing the gap between "an error happened" and "I understand why it happened".
  • Performance tracing shows you where real page loads and requests are actually slow, which is often a different answer than where you'd guess the slowness is from reading the code.
  • The point of monitoring isn't the dashboard itself — it's that what you learn from it should directly change what you build or fix next, closing the loop back into the product.

Shipping is a transition, not a finish line

It’s easy to treat deployment as the end of the project, but launch is really the point where the nature of the work changes. Before launch, you’re building against your own assumptions about how the app will be used. After launch, real users generate real signal about what actually happens, and the question becomes whether you’re set up to receive that signal or whether you’re going to learn about problems the hard way — from a confused support email, a one-star review, or silence from users who just quietly left.

Error tracking: finding out before they tell you

Tools like Sentry hook into your application and automatically capture unhandled exceptions with a full stack trace, the request or user context around it, and often the exact release that introduced it. The difference this makes is less about catching more errors and more about catching them faster and with more detail than a user report ever gives you. A bug report says “it didn’t work when I tried to save.” An error tracker says which line threw, what the input was, and which deploy introduced it. One of those is immediately actionable; the other is the start of a long reproduction hunt.

Session replay: seeing what actually happened

A stack trace tells you what broke in the code. It doesn’t tell you what the user was doing right before it broke — which field they filled in what order, whether they double-clicked a button, whether they were on a flaky connection. Session replay records that sequence of behavior so you can watch it alongside the error, closing the gap between “an exception was thrown” and “I understand the exact user action that caused it.” That gap is often where the real bug — a race condition, an edge case in a form, a timing issue — actually lives.

Performance tracing: where the app is slow in reality

Guessing where an app is slow from reading its code is unreliable, because real slowness usually comes from the interaction between your code and real-world conditions: a database query that’s fast with ten test rows and slow with ten thousand, a network request that’s instant on your office wifi and sluggish on a user’s mobile connection. Performance tracing measures what’s actually happening for real requests and real page loads, which routinely points at a different bottleneck than intuition would. It’s the same shift error tracking makes, applied to speed instead of correctness: stop guessing, start measuring.

Closing the loop back into the product

None of this matters if the data just sits in a dashboard nobody looks at. The point of monitoring is that it should change what you prioritize next — an error that’s hitting 40% of sessions becomes the next fix regardless of what was on the roadmap, a slow page that’s costing you users becomes worth the optimization work, a session replay showing users abandoning a form at the same step becomes a design problem to solve. Monitoring earns its cost only when it’s actually feeding back into decisions about what to build or fix next, not when it’s just a tool you installed and stopped looking at.

Check yourself

  1. 01What's the practical difference between learning about a bug from monitoring versus from a user complaint?

    Monitoring typically gives you a stack trace, the request context, and often a session replay automatically and immediately, while a user complaint gives you a vague description after the fact with none of that detail, forcing you to reproduce the problem from scratch.

  2. 02What does session replay add beyond an error report?

    It shows the actual sequence of clicks, inputs, and navigation a real user made leading up to the failure, which turns "this error occurred" into "here is exactly what the user was doing when it happened" — often the key to understanding why it happened at all.

  3. 03Why is performance tracing useful even if you're confident about where your app's slow parts are?

    Real-world performance is shaped by actual data sizes, network conditions, and usage patterns that are hard to predict from reading code alone; tracing shows you where load actually is slow in production, which frequently differs from where you'd guess.

Notes

Private to you

Esc
↑↓ navigate↵ open? shortcuts

Keyboard shortcuts

Press Esc to close

Anywhere

⌘K
Search and commands
/
Search
?
This sheet
Esc
Close

Reading a lesson

J
Next lesson
K
Previous lesson
B
Bookmark