From “something broke” to “we fixed it, and it worked”
Bring support tickets into the same feedback inbox as in-app reports. Send feedback and alerts to Slack, Microsoft Teams or your own endpoint. Turn any problem into an issue in your tracker with the context filled in. Seven days after the issue is closed, Metrickle measures whether the fix moved the metric.
Accessibility barrier reported on /invoices/new
“The due-date picker can’t be reached with Tab.”
Create issue turned it into ENG-12 in Linear. Seven days after it closed, accessibility reports on /invoices/new had fallen from 9 to 1.
Hear about problems where you already work
Every integration here comes with every plan, Free included. Add a Slack incoming webhook, a Microsoft Teams workflow or your own HTTPS endpoint to any app, and choose what goes there. Alerts are checked every hour. Task alerts are sent at most once a day, new hotspots at most once a week and release drops once, so an ongoing problem doesn’t post every hour.
When a release went out in the two days before an alert, the message names it. That’s often the cause.
| Event | When it’s sent | Webhook type |
|---|---|---|
| Feedback reports | Every “Report a problem” submission. Accessibility barriers get their own headline and list the reporter’s accessibility settings. | feedback.created |
| Task success drops | A saved task’s success rate over the last 24 hours is at least 15 points below its rate over the previous 7 days, with enough attempts on both sides. Names the accessibility setting doing worst. | alert.task_success_drop |
| New friction hotspots | An element, form or page started causing rage, dead or error clicks, u-turns or form errors in the last 24 hours, and wasn’t a hotspot the week before. | alert.new_hotspot |
| Protected task gaps | Since the latest release, people using an accessibility setting finish a protected task clearly less often, or more slowly, than people using none, or people on one browser, operating system or device type fall clearly behind everyone else. | alert.contract_broken |
| Release drops | A release’s verdict became Drop found: a goal or protected task fell past its limit, clear of noise, or a group fell behind since the release. Sent once, by email by default. | alert.release_dropped |
| Release verdict | A release’s first verdict, when it’s No drop or Early signal. In the inbox by default; choose it for Slack, Teams, a webhook or email. | release.verdict |
| Cases opened | A case opened on a protected task with a gap, by Metrickle or by a person or assistant. Names the step, element and group that lose most, how many people didn’t finish, and what it has cost so far. | case.opened |
| Cases closed | A case was fixed and verified for the group that broke, or an owner dismissed it. Sent with the before and after. | case.closed |
| Fix results | Seven days after a linked issue is closed: the metric before vs after. | issue.measured |
- Visitor text stays text. A feedback message can’t ping a Slack channel or add links in Teams.
- A delivery log for every destination, with failures flagged at the top of the Integrations page.
- Retried when it fails: network errors, timeouts and 5xx responses are tried twice more.
- Slack and Teams URLs are treated as secrets: only owners and admins add them, and they’re shown masked.
Turn a problem into an issue in one step
Connect your tracker once for the workspace with an access token: Linear, GitHub Issues, Jira Cloud, GitLab, Azure DevOps Boards, Shortcut, Asana, ClickUp, Trello or YouTrack. Self-managed GitLab and YouTrack work when they’re reachable over HTTPS from the internet; Jira Data Center and GitHub Enterprise Server aren’t supported yet. Then pick a team, repository, project or list for each app. “Create issue” on a feedback report, a friction hotspot or a saved task opens a draft you can edit before it’s sent.
The draft brings the context a developer needs: the page, platform and accessibility settings, where attempts stopped, the friction in abandoned attempts, the accessibility setting hit hardest, and the last seven days' numbers.
- Tokens are encrypted at rest with AES-256-GCM and never shown again. Disconnecting deletes the token; the issues it created stay in your tracker.
- Checked when you connect: you see whose token it is before anything is created.
- The reporter’s words are quoted literally, so an “@someone” in feedback doesn’t notify anyone.
- Any member can file an issue; only owners and admins connect accounts.
| Issue | Metric | Before → after |
|---|---|---|
| ENG-12 Due-date picker unreachable by keyboard | Accessibility reports on /invoices/new | 9 → 1 |
| #48 Rage clicks on plan toggle | Sessions hitting it | 6.2% → 0.4% |
| WEB-7 Logo upload fails on Safari | Similar reports | 11 → 2 |
Measured over the 7 days before an issue was opened and the 7 days after it was closed.
Count support tickets as feedback
Connect Zendesk (your subdomain, an agent email and an API token) or Intercom (an access token) to an app; Zendesk’s webhook is added for you when the token belongs to an admin. New tickets and conversations arrive by signed webhook within seconds, with an hourly sync as a fallback, and the last seven days come in when you connect. Each one lands in Feedback with a link back to the ticket.
Tickets are sorted into Broken, Confusing, Idea, Accessibility or Other by their tags first, then by keywords you can edit. Claude can do the sorting instead when your Metrickle server has an Anthropic key. Tags such as billing or spam can be skipped.
When the requester is someone your app has identified, by user ID or by email, the ticket counts as a problem report: it takes back a task they finished in the seven days before, and an accessibility barrier counts against the setting they were using. It’s the support queue telling you a conversion didn’t stick.
- No raw emails at rest. Send
emailin identify traits and Metrickle keeps only a keyed hash of it. A requester is matched by the same hash. - Only what’s needed is copied: the subject and, if you want it, a 280-character excerpt with emails and numbers masked. The conversation stays in your support tool.
- Every delivery is verified: Zendesk’s webhook signature or Intercom’s X-Hub-Signature, and the ticket is read back from the API rather than trusted from the payload.
- Erasure covers it. Erasing a person by user ID or email deletes their imported tickets, and they aren’t imported again.
Know whether the fix worked
Every issue created from Metrickle records its metric for the seven days before it was opened. Metrickle checks the issue every few hours; seven days after it’s closed as done, it measures the same thing again and shows the result on the Fixes page, and in Slack, Teams or your webhook if you choose “Fix results”. Issues closed as not planned aren’t measured.
| Created from | Metric | Better when it goes |
|---|---|---|
| A saved task | Task success rate | Up |
| A friction hotspot | Share of sessions hitting that element or form | Down |
| A feedback report | Reports in the same category on the same page | Down |
| A case | The case’s own number for the group that broke (task success, clean successes or starts). Closing the issue as done marks the case’s fix shipped, and the case verifies itself from there. | Up |
Mark every release, and get its verdict
Each app has a deploy hook URL. Call it from CI, or point a GitHub, Vercel or Netlify webhook at it, and every production release appears as a marker on the Overview chart, with the same list in text under the chart. New app versions seen in your events are added automatically, which suits iOS, Android, Flutter and React Native apps.
Every release then gets a verdict: did it fail, and for whom. A CI step after deploy can ask for it with the same hook token, and fail the build on a drop if you want a release gate. See wait for a release verdict in CI.
# Copy the URL from Integrations → Releases → Deploy hook
curl -X POST "$METRICKLE_DEPLOY_HOOK" \
-H "content-type: application/json" \
-d '{"version": "4.13", "description": "Checkout keyboard fix"}'
| Sender | Recorded as a release | Ignored |
|---|---|---|
Any CI step (curl) | A JSON body with version, and optionally description, url and environment. Or ?version= in the URL. | Requests with no version |
| GitHub webhook | Published releases (tag name), and successful deployment statuses | Pings, drafts, pre-releases, failed and preview deployments |
| Vercel webhook | Deployment succeeded, production target (short commit SHA) | Preview deployments |
| Netlify outgoing webhook | Deploy succeeded (short commit SHA) | Deploy previews and branch deploys |
Already on Segment or RudderStack? Start without the script
Add Metrickle as a webhook destination in Segment or RudderStack, and the pages, screens, events, revenue and sign-ins you already track arrive in Metrickle. Each app has its own endpoint and secret on the Integrations page, with a live check that shows the first event arriving.
Events are filtered much as the script’s are: crawlers and pages outside your domains are dropped, likely AI agents are kept apart from people’s numbers, an event’s integrations flags are respected, and in consent-required mode only events whose consent fields grant your categories are kept (Segment consent categories or RudderStack consent ids such as OneTrust’s).
- Retries never count twice: each message’s
messageIdbecomes its event id. - Running the script too? Turn off pages and screens for the source and the script records them, with friction and accessibility context, so nothing is counted twice.
- Signed or secret-header requests: Segment’s shared-secret signature, or the secret in a header.
# Endpoint and secret from Integrations → Event sources
curl -X POST "$METRICKLE_SOURCE_URL" \
-H "content-type: application/json" \
-H "x-metrickle-secret: $METRICKLE_SOURCE_SECRET" \
-d '{"type": "track", "event": "Order Completed",
"userId": "u_123", "messageId": "msg-1",
"properties": {"order_id": "1001", "revenue": 89}}'
| Call | Stored as |
|---|---|
page | A pageview with path, title, referrer and UTM campaign |
screen | A screen view, named like the iOS, Android and Flutter SDKs name them |
track | A custom event with its properties. Order Completed counts as revenue and Order Refunded as negative revenue, so a refund takes back the task success it undoes |
identify, alias | Links the anonymous id to the user, so one person before and after sign-in, on every device, is one visitor. Traits that name the person (email, name, phone, address) are never stored |
group | A $group event with the group id |
Some things only happen on the device, so they need Metrickle’s script or an SDK alongside the source:
| Feature | Why a source can’t send it |
|---|---|
| Friction: rage, dead and error clicks, slow controls, u-turns, form errors and form abandons | Detected from clicks, taps and form state on the device |
| Accessibility settings, such as keyboard navigation, zoom, large text, reduced motion and screen reader (in your iOS and Android apps) | Read from the browser’s and phone’s settings. Without them, events can’t be split by accessibility setting |
| Session replay and heatmaps | Recorded in the browser |
| Surveys, “Report a problem” and study tasks | Shown on the device |
| Visitor location | Requests come from Segment’s or RudderStack’s servers, not the visitor |
Count the money people keep, not just what they paid
Connect your Stripe account or RevenueCat project to an app. Purchases, renewals, refunds and subscription cancels arrive server-side, on the same person the SDK identified, so you don’t have to send them as custom events. A refund within seven days takes back the task that person completed, a cancel does too when it’s the task’s undo step, and revenue kept and a case’s money lost so far are real numbers.
Stripe connects with a restricted key that can only read (charges, refunds, customers, subscriptions, Checkout Sessions and events), a webhook signed with your endpoint’s secret, or both. With the key, the last 30 days are backfilled and anything a webhook misses is caught up every 15 minutes. RevenueCat sends its webhook with an Authorization value Metrickle makes for you.
To tie a payment to a person, give the provider the id you pass to identify(): Stripe Checkout’s client_reference_id or metadata.metrickle_user_id on the customer, and RevenueCat’s app user id. A payment that arrives before Metrickle knows its customer waits, and is recorded as soon as it does.
- Each payment is counted once, however many events Stripe sends about it, and a webhook redelivered or read again from the API changes nothing.
- Already sending purchases with revenue from the app? Keep the event as a task step but drop its
revenueproperty, so revenue comes from one place. - One reporting currency, chosen when you connect. Other currencies are converted at that day’s ECB rate, and the original amount is kept on the event.
- Signatures are checked on every delivery; refused ones show on the Integrations page with the reason.
- Keys and secrets are encrypted at rest and never shown again. Secret keys that can change your account are refused.
- Test mode and sandbox purchases are left out unless you turn them on to try the setup.
- Free-text cancellation comments are never stored; the reason and Stripe’s feedback choice are.
// The same id your app passes to metrickle.identify()
const session = await stripe.checkout.sessions.create({
mode: "subscription",
line_items: [{ price: "price_…", quantity: 1 }],
client_reference_id: user.id,
subscription_data: { metadata: { metrickle_user_id: user.id } },
success_url: "https://example.com/welcome",
});
// Mobile apps with RevenueCat: log in with the same id
await Purchases.logIn(user.id);
| Metrickle event | From Stripe | From RevenueCat |
|---|---|---|
purchase (revenue) | Checkout in payment mode, a PaymentIntent marked with the user, a one-off paid invoice | Non-renewing purchase |
subscription_started (revenue) | The first paid invoice of a subscription | Initial purchase |
subscription_renewed (revenue) | A renewal invoice paid | Renewal |
trial_started | A subscription created in a trial | Initial purchase of a trial |
refund (negative revenue) | Each refund on a charge, partial refunds included | A cancellation by customer support with a negative price |
subscription_canceled | The moment someone asks to cancel (now or at period end), or a subscription ends for failed payments | Cancellation (unsubscribed, billing error…) |
subscription_ended | The subscription is deleted | Expiration |
Webhook reference
Generic webhooks receive a JSON POST with the event type in metrickle-event and a unique id in metrickle-delivery. Any 2xx response counts as delivered.
Every request is signed with the secret shown when you added the webhook. metrickle-signature is t=<unix ms>,v1=<hex>, where the hex is an HMAC-SHA256 of the timestamp, a full stop and the raw body. Reject requests more than five minutes old.
Reports that came from Zendesk or Intercom have data.source set to { label, url }, for example Zendesk #482 and a link to the ticket. It’s null for in-app reports.
content-type: application/json
metrickle-event: feedback.created
metrickle-delivery: evt_…
metrickle-signature: t=1790841234000,v1=5f2c…
{
"id": "evt_…",
"type": "feedback.created",
"createdAt": 1790841234000,
"app": { "id": "app_…", "name": "Quillmere" },
"url": "https://app.metrickle.com/apps/app_…/feedback",
"data": {
"category": "accessibility",
"accessibilityBarrier": true,
"message": "The due-date picker can't be reached with Tab",
"path": "/invoices/new",
"a11y": ["keyboard"]
}
}
import { createHmac, timingSafeEqual } from "node:crypto";
// header: t=<ms>,v1=<hex HMAC-SHA256 of "<t>.<raw body>">
export function verify(rawBody, header, secret) {
const { t, v1 } = Object.fromEntries(header.split(",").map((p) => p.split("=")));
if (Math.abs(Date.now() - Number(t)) > 5 * 60_000) return false;
const expected = createHmac("sha256", secret).update(`${t}.${rawBody}`).digest("hex");
return v1?.length === expected.length && timingSafeEqual(Buffer.from(expected), Buffer.from(v1));
}
See which release is costing you conversions, and who it broke for
Free to start. One script tag on the web, one SDK on mobile, and no cookie banner in cookieless mode.
Start free