How do I know if my fix didn't work?

Verify in the field, per version, whether the crash actually stopped, since a fix that looks right can fail to work. The direct sign is the crash still occurring on the version that shipped the fix (you fixed it, shipped it, and the crash is still happening on the fixed build as players adopt it). A sign is continued reports or complaints about the bug after the fix shipped (players still hitting the issue). And a sign is the crash rate not dropping as expected (if a fix for a high-impact crash should reduce your crash rate but it doesn't on the fixed version). To verify, track crashes per version: watch the fixed build's data, and check whether the crash that was supposed to stop actually stopped (the signature disappearing on the fixed version as players adopt it) and whether the crash rate dropped as expected. If the crash still occurs on the fixed version, players keep reporting it, or the crash rate didn't drop, your fix didn't work (or only partially worked). The key is that the only way to know a fix worked is to verify in the field, per version, that the crash actually stopped, you can't just assume the fix worked because the code looked right or stopped reproducing locally, since a fix can fail to address the actual field condition, or fix only one of several causes grouped under the same signature (a partial fix). So you know your fix didn't work from the crash persisting on the fixed version (the direct sign, seen via per-version tracking), continued reports, and the crash rate not dropping, all of which per-version crash tracking reveals by letting you watch the fixed build and confirm whether the crash genuinely stopped. Verifying fixes in the field, per version, is essential precisely because fixes can fail or be partial, and the per-version field data is what tells you whether your fix actually worked or didn't.

Why didn't my bug fix work?

A fix can fail to work for a few reasons. It may not have addressed the actual cause: the fix looked right and may even have stopped the bug from reproducing in your testing, but it didn't fix the real field condition (the bug occurs under conditions you didn't replicate, so your fix, validated against your reproduction or assumption, didn't address the actual trigger in the field). It may have been a partial fix: the crash signature you fixed had multiple underlying causes (different conditions producing the same signature), and you fixed one but not the others, so the crash continues at a reduced rate (the fix worked partially). It may have masked the symptom rather than fixing the cause: the fix suppressed the visible symptom but left the underlying cause, so the bug persists or returns through the same path. Or it may have introduced its own problem (a fix that's incorrect or that broke something else). The common thread is that a fix that looks right, or that stops the bug in your testing, isn't guaranteed to work in the field, since the field conditions may differ from what you tested or assumed, and a signature may have multiple causes. This is why verifying in the field, per version, matters: it confirms whether the fix actually worked (the crash stopped on the fixed version for real players) rather than assuming it did. So your bug fix didn't work likely because it didn't address the actual field cause (validated against your testing/assumption, not the real condition), or it was partial (fixed one of several causes under the same signature), or it masked the symptom (leaving the cause). To figure out which and fix it properly: verify in the field (per-version tracking shows the crash still occurring, confirming the fix failed), and use the captured context (stack trace, device, conditions, breadcrumbs) to understand the actual field cause, especially the conditions you may not have replicated, so you can address the real trigger. If it's a partial fix (the crash continues at reduced rate), the captured context of the remaining occurrences reveals the other causes under the signature. The key is that a fix can fail because the field reality differs from your testing/assumptions, so you fix it by understanding the actual field cause (from the captured context) and addressing it, then re-verifying in the field. Verifying fixes in the field (rather than assuming) is what catches the failed and partial fixes, so you can address the real cause rather than believing a non-working fix resolved the bug.

How do I verify a bug fix actually worked?

Confirm the crash stops occurring on the build that shipped the fix, in the field, using per-version tracking, rather than assuming it worked because the code looked right or stopped reproducing locally. Tag the fix to the build it shipped in, then watch that version's crash data as players adopt it: if the crash that was occurring on previous builds no longer appears on the fixed build (the signature disappears in the field on the fixed version), the fix is verified in the real world. Check both that the specific crash stopped (the signature gone on the fixed build) and that the crash rate dropped as expected (if it was a high-impact crash, the fixed build's crash rate should reflect its removal). This per-version field verification matters because fixes that seem correct can fail to address the actual field condition, or fix only one of several causes grouped under the same signature (a partial fix), so the bug looked fixed in your testing but persists in the field, only watching the fixed version's data confirms whether the crash actually stopped for real players. It's especially important for crashes you couldn't reproduce (you can't confirm those by local re-testing, since you couldn't make them happen, so watching whether they stop in the field is the only reliable verification). Per-version tracking also lets you catch the opposite problem (a fix that introduced a regression elsewhere) by comparing the fixed build's overall crash behavior against the previous one. And it ensures honesty when you tell players a bug is fixed (confirming the crash actually stopped on the shipped version before announcing it). So you verify a fix worked by tagging it to its build, tracking crashes per version, and confirming the crash disappears on the fixed version in the field as players adopt it (and the crash rate drops as expected), which is real evidence the fix worked, in contrast to the assumption that it did. This per-version field verification, watching the crash stop on the build that fixed it, is how you know a fix actually worked, catching the failed and partial fixes (where the crash persists or continues at reduced rate on the fixed version). The key is to verify by evidence (the crash stopped on the fixed version, in real player data) rather than by assumption (the code change looks correct or stopped reproducing locally), since the gap between a fix that looks right and one that actually works is exactly where failed fixes hide, and per-version field verification is what closes that gap by confirming the fix genuinely stopped the crash for players. Verifying fixes in the field, per version, should be a standard part of fixing bugs, since a fix isn't done when you write it, it's done when you've verified it actually worked, which only the field data on the fixed version can confirm.

Signs Your Fix Didn't Work

Quick answer: Watch for the crash still occurring on the fixed version, continued reports after the fix, the crash rate not dropping, and the bug recurring under conditions you didn't address. Verify fixes in the field, per version.

Writing a fix isn't the same as fixing the bug, a fix that looks right can fail to work, so verifying matters. Here are the signs your fix didn't work.

The Crash Still Occurring on the Fixed Version

The direct sign is the crash still occurring on the version that shipped the fix, you fixed it, shipped it, and the crash is still happening on the fixed build. If the crash persists on the fixed version (as players adopt it), the fix didn't work, it didn't address the actual cause in the field.

Bugnet tracks crashes per version, so a crash persisting on the fixed build is identifiable. The crash still occurring on the fixed version is the direct sign your fix didn't work, and per-version tracking is how you verify, you watch the fixed build's data, and if the crash that was supposed to stop is still occurring on it, the fix failed, which you'd only know by checking per version (not by assuming).

Continued Reports or Complaints After the Fix

A sign is continued reports or complaints about the bug after the fix shipped, players still hitting the issue you thought you fixed. If players keep reporting the bug after the fix, it didn't work (or didn't fully work), the fix didn't resolve the issue for players in the field.

Bugnet captures crashes from the field, so continued occurrences after a fix are identifiable. Continued reports or complaints after the fix are a sign it didn't work, and capturing crashes from the field (not just relying on reports) confirms whether the bug is still occurring (and how much), since reports understate it, the field data shows whether the crash actually stopped or is still happening despite the fix.

The Crash Rate Not Dropping as Expected

A sign is the crash rate not dropping as expected after the fix, if a fix for a high-impact crash should reduce your crash rate but it doesn't (on the fixed version), the fix didn't work, or only partially worked (e.g. fixed one of several causes grouped under the same signature). The expected improvement not materializing signals a failed or partial fix.

Bugnet tracks crash rate per version, so the expected drop (or its absence) is visible. The crash rate not dropping as expected is a sign your fix didn't work (or only partially), and per-version crash-rate tracking is how you see it, you can check whether the fixed build's crash rate dropped as the fix should have caused, and if it didn't, the fix failed or was partial, which the per-version data reveals so you can address it.

Watch for the crash still occurring on the fixed version, continued reports after the fix, the crash rate not dropping, and the bug recurring under conditions you didn't address. Verify fixes in the field, per version.