Notifio is a desktop app that watches rental search pages and emails you when a new listing appears. The email is not a notification about the product, it is the product. So I went looking for the other half of that relationship: what a recipient can do about it, and what we do when they do something.

The answer is nothing, in both directions, and only one of the two is defensible.

The templates

$ wc -l src/lib/emails/*.ts 52 src/lib/emails/activation.ts 240 src/lib/emails/alert.ts 107 src/lib/emails/free-access.ts 399 total 

Three files, six kinds of message between them, eight builder functions in the alert file alone because every kind has an HTML and a plain-text twin.

$ grep -rni "unsubscribe" src/lib/emails src/lib/resend.ts | wc -l 0 $ grep -rni "list-unsubscribe" src | wc -l 0 

No unsubscribe link in any template. No List-Unsubscribe header, which is unsurprising once you look at the sender, because our sendEmail wrapper has no way to set one:

export async function sendEmail({ from, to, subject, html, text, replyTo }: { from: string; to: string | string[]; subject: string; html?: string; text?: string; replyTo?: string; }) { 

Six parameters, no headers. Adding a header to one message means widening the only function that sends mail in the entire product.

The one Unsubscribe we do ship

There is exactly one hit for the word in the whole repository:

$ grep -rni "unsubscribe" src | wc -l 1 src/components/demos/NotificationDemo.tsx:293 
<p className="text-[8px] text-[#2a2a2a]">Sent by Notifio · alerts@notifio.app · Unsubscribe</p> 

That is the fake email inside the animated Mac window on the homepage. It is drawn at 8 pixels in near-black on black, it is not a link, and it advertises a capability the real email does not have. The address in the same mockup is not one of ours either, which a previous address census already caught. A demo of an email tends to be drawn from memory of other emails, and other emails have unsubscribe footers, so ours grew one.

Worth knowing: that line is not in the served HTML at all. The mockup is a client component with a three-phase animation and the message only renders in the last phase, so it reaches eyes without reaching a curl. It is the kind of copy no audit of the markup will ever find.

Why no unsubscribe link is the right answer

Every message we send goes to the person who installed the app, at the address their licence is keyed on, and the server does not accept a recipient from the client:

if (!license || license.email !== email || !license.active) { return NextResponse.json({ error: "Invalid or inactive license." }, { status: 403 }); } ... const { success, error } = await sendEmail({ from: EmailAddresses.NOREPLY, to: email, subject: `Notifio: ${totalCount} new ${totalCount === 1 ? "listing" : "listings"} on ${siteNames}`, html: buildAlertEmail(alerts, totalCount), text: buildAlertText(alerts), }); 

All four to: values in the alert route are the address that just authenticated. There is no field anywhere in the product for "send alerts to somebody else", which means Notifio cannot be used to mail a stranger, which in turn means there is no list to leave. These are transactional messages in the strict sense: each one exists because a person on that machine set up a search that matched.

So a one-click unsubscribe would be the wrong control. Unsubscribing from your own alerts would stop the thing you paid £20 on the pricing page to have, and it would do it from a mail client rather than from the app, which is where the state actually lives.

Where the off switch really is

This is the part that deserves scrutiny. The desktop app's config has exactly two knobs that touch alerts:

export interface Config { email: { to: string }; sites: Site[]; license?: { email: string; token: string }; notifications?: { /** Native desktop banner the moment a listing is found. */ desktop?: boolean; }; } 

notifications.desktop turns off the native banner. There is no corresponding flag for email. Email is not a channel you can switch off; it is the one channel that must not fail quietly, and the only ways to stop it are to pause the search, delete the search, deactivate the licence, or quit the app.

For a tool whose whole promise is "you will hear about it first", that is coherent. The emails stop when the watching stops, and the watching is a thing you can see and press. But the asymmetry is still odd when you write it out: the channel the user can turn off in one click is the one that is free and local, and the channel that costs us money per message and travels to another company's inbox is the one with no setting at all. If somebody wants alerts without email, today the answer is that there is no such mode.

The feedback we throw away

The other direction is harder to defend. Our mail provider posts delivery events to a webhook, and here is the whole handler:

switch (type) { case "email.received": { await handleEmailReceived(data); break; } case "email.delivered": case "email.bounced": case "email.delivery_delayed": case "email.complained": // These events are logged but don't require action console.log(`[resend-webhook] Event: ${type}`, data); break; default: console.log(`[resend-webhook] Unknown event: ${type}`); break; } 

Five named event types. One does real work: inbound mail to our own addresses gets parsed and forwarded. The other four share a console.log and a comment asserting that no action is required.

For email.delivered and email.delivery_delayed the comment is true. For the other two it is a decision dressed as a fact.

email.bounced means an address we are sending alerts to does not exist any more. The monitor on that laptop keeps polling, keeps finding listings, and keeps posting them to an endpoint that keeps handing them to a mail server that keeps rejecting them, every time something new appears, forever. Nothing in the product knows. The licence is still active, the app shows a green status, and the user sees no listings because the only channel that was ever going to show them is a dead mailbox.

email.complained is worse in a different way. It means a recipient pressed "report spam" on an alert they set up themselves, most likely because they forgot the app was running. That event is the single most valuable signal a sender can get, because the mailbox provider is telling you directly that your reputation is about to cost you. We log it and keep sending, which means the next complaint comes from a user whose alerts started landing in spam because of the first one.

Both of those have an obvious handler and both of them need a product decision rather than a code change, which is why neither has one yet. A bounce should stop email alerts for that licence and surface it in the app, because the app is the only place that can tell the person. A complaint should stop them immediately and not resume, because arguing with a spam report is not a thing a 20 pound utility gets to do. In both cases the app needs to be able to say "your alerts are off and here is why", which means the validate response the app already polls needs one more field, and the window needs one more notice. That is two days of work to close a loop that is currently a console.log.

What I measured, in one place

email templates 3 files, 399 lines message kinds 6 unsubscribe links in real emails 0 List-Unsubscribe headers 0 `headers` parameter on our sender absent occurrences of "unsubscribe" in repo 1 (a mockup on the homepage) delivery event types handled 5 of those, acted on 1 bounces that stop anything 0 complaints that stop anything 0 ways a user can stop email alerts 4, all of them inside the app 

The honest summary is that the outbound half of our email is careful and the inbound half does not exist. That is a common shape for a small product, and it is worth naming, because the outbound half is the part you look at every time you edit a template and the inbound half is a webhook you wrote once in an afternoon and have not opened since.

If you want to see what the real alert looks like, the app is on the download page, and the help page is the page that will have to explain any off switch I add.