How to Show Users a Broken Integration Before They File a Ticket
Silent integration failures need detection that tells users first.
A broken integration should reach users as a clear in-product status message before they have to report the failure to support. Closing that gap takes detection built for these failures and linked to the product UI. The awkward irony is that, during an incident, engineers have the least time to maintain the systems that detect trouble and explain it. Those systems need to work without waiting for someone to remember them.
The gap that support tickets already close for you
A support ticket about missing data does more than request help. It supplies a discovery signal the engineering team should already have had. By then, the user has noticed a problem, decided it is not their mistake, and stopped working long enough to describe it. They have become an unpaid monitoring service. Unlike the team responsible for the integration, though, they cannot inspect its credentials, delivery history, or upstream dependencies.
An integration can remain visibly connected while its OAuth token expires, its webhooks stop arriving, or an upstream API returns 4xx responses that nobody watches. The team gets no alert that tells it what went wrong, and the application can look healthy even as data stops moving. The connection exists in name only. Reactive support triage begins after this gap has already cost the user time, and during an incident it competes with remediation for the same engineers’ attention.
Why integration failures stay silent longer than other outages
Integrations sit between systems that each see only part of the work. One system knows it ran a process and another knows it got a request, but neither may know whether the right data arrived and was processed. Local success is not end-to-end success. Workday can report its own process as “Completed” without knowing whether the receiving system processed anything. A zero-record run can therefore look successful, while application-layer reporting can miss expired credentials or schedules that quietly stopped existing.
A sender can log a delivery attempt even if the team gets no alert when the receiving endpoint rejects it. Delivery errors exist before the silence begins. The dangerous transition is from unsuccessful attempts to no further delivery, leaving a team unaware that the webhook has stopped doing its job.
OAuth expiry adds a timed version of the same problem. A credential works until it does not, and the failure may remain hidden until a sync runs and silently returns nothing. Third-party outages complicate diagnosis further because a provider’s failure surfaces as a broken integration in your product. The symptom does not identify the culprit. Generic uptime monitoring cannot resolve these gaps by asking whether the application is reachable, because reachability says little about credentials, delivery, scheduling, or the health of the system at the other end.
What health checks can and cannot see on their own
An endpoint answering a request proves only that it can answer that request. That is a narrow but important distinction. A more useful check confirms that the integration can authenticate, that its credential remains valid, and that a test payload can make a round trip. Each additional check tests a part of the path that a simple reachability probe leaves untouched.
If authentication can break, a check that never authenticates cannot detect that break. If delivery can fail beyond the first endpoint, checking only that endpoint stops short of the risk. The test must reach the failure boundary. Otherwise, a healthy result is easy to read as a promise the check was never designed to make, rather like declaring a restaurant excellent because someone answered the phone.
Even a successful round trip has limits. It leaves open whether a scheduled sync ran, whether it delivered records, or whether a webhook registration is still producing calls. A credential that is valid now may expire before the next sync cycle, and a recurring job may quietly stop being scheduled. These failures need a different kind of evidence. Health checks test what happens when something is asked to work, while event inspection and silence detection check whether the real work is happening at all.
Webhook event inspection as a first-class monitoring primitive
Webhook event streams are not just delivery plumbing. They contain diagnostic signals about the state of the integration, including changes a periodic endpoint check may never see. A deactivation event means the webhook has stopped being called altogether. That is a change in registration state. Treating it as monitoring data lets the team detect the loss of delivery instead of waiting for a user to notice the missing result.
Repeated 4xx responses show that an endpoint exists but is rejecting payloads, often because of schema drift or authentication changes. Retry exhaustion is the point where the upstream has given up and events are being dropped for good. OAuth events provide another early-warning channel. Refresh failures, revocations, and expiry warnings can reveal credential trouble before a production sync depends on a credential that no longer works.
To catch failures from those signals, teams should send high-signal event types to Slack, email, or PagerDuty with enough context for someone to act. The alert needs the integration name, event type, and last known state, so the recipient can understand the problem without first opening a dashboard. Delivery logs alone do not provide that service. A log that nobody queries during normal operations is evidence waiting for an investigator. By the time someone searches it after a support ticket, the exercise is archaeology with a customer waiting on the result.
Detecting zero-signal failures: when nothing happens and no error fires
The hardest failures produce no event that points to trouble, so the system looks quiet even though it is broken. If a sync runs every hour and should produce a webhook event every hour, then an expected window passing without that event is a reason to alert. The monitor is no longer looking for an error message, but for a missing sign of healthy operation.
Heartbeat monitors express this pattern directly. A process sends a ping on a known schedule, and the monitor alerts when the ping stops arriving. Time-window assertions check for expected integration events in the same way, without needing a separate heartbeat. Schedule drift is a clear use case. A recurring job that is no longer queued may produce neither a failed run nor an error to inspect, so the absence of expected activity is the signal that exposes it.
A run can also arrive on time and accomplish nothing. A sync marked “Completed” with zero records looks successful at the infrastructure layer, so detecting that failure requires inspecting payload content or record counts. Event-count thresholds let teams alert when a run delivers fewer records than a configured minimum. The expected amount must be explicit.
These checks show when activity is missing, but on their own they do not explain why. An upstream outage and a broken connector can leave the same empty event window at your end. Provider status supplies a separate diagnostic signal. Cross-referencing it with the silence alert helps distinguish a dependency failure from trouble in the integration itself, and status page aggregation can support that comparison. The core detection pattern remains the expected event and its absence.
Surfacing failures in-product before users reach support
Detection changes what engineers know, but it does not necessarily change what users see. A Slack alert sent to the team leaves the user with the same stale report or missing data unless the detection layer also feeds the product UI. Communication has to cross that final boundary. The design goal is for users to encounter an honest status message before they have to infer a failure from the integration’s output.
A connection or settings screen can show connected, degraded, or failed states updated in real time from monitor data. That avoids making the visible status depend on an administrator remembering to change it. Settings alone are not the whole experience. A user reading a report needs context where the affected data appears, such as “Your CRM sync hasn't run recently — check your integration settings”.
The wording should then explain what broke, what the user can do, and whether the team is already aware. Depending on the failure, that action may be reauthentication, checking a webhook endpoint, or contacting support with a reference ID. “Integration error” leaves all of that work undone. A useful message gives the user a next step without suggesting that every failure is theirs to fix. When the problem is an upstream dependency, the communication should reflect that distinction rather than blur it into a generic connection warning.
Precision also depends on component-level status. Payment API degradation is not the same problem as documentation being unavailable, and users affected by one should not be alarmed by the other. The visible warning should match the affected function. That granularity makes an in-product message useful at the point of work, rather than turning every integration incident into a product-wide warning. It also lets the product say what is still working without pretending the broken part is healthy.
Connecting the detection and communication layers without creating new failure points
The link between monitoring and communication can fail too. When an external monitoring tool updates a status page through a webhook relay, that relay is another integration that can fail. If it breaks silently, the page can show “Operational” during a real outage. The objection is entirely fair.
For teams already using Datadog, New Relic, or Prometheus, that does not make the connection unworthy of maintenance. It means the relay needs health checks of its own rather than being treated as plumbing that will always work. Monitor the route that publishes the result. Where a built-in detection-to-communication path covers the failure class that needs attention, preferring it over a bolt-on relay avoids adding a handoff solely to move the same signal.
The engineer responding may not be the engineer who built the integration, so each alert should include the integration name, event type, last known healthy state, and a direct link to the relevant dashboard. Context should arrive with the alert itself so the recipient can begin acting, with the dashboard link available for investigation.
The practical target is a detection path that reaches both audiences at roughly the same time. An engineer receives the Slack notification while the user sees an accurate in-product status message, before missing data prompts a support ticket. Neither should depend on a manual status update. Getting there requires treating the monitoring relay as a monitored integration and the user-facing state as part of failure handling.



