DEV Community: houseofmvps

I stopped 40% of my payment failures before they happened with one Stripe API call and a cron job

houseofmvps — Thu, 16 Apr 2026 17:24:00 +0000

Stop Churn Before It Happens: The Highest-ROI Dunning Move Most SaaS Founders Ignore

Most dunning advice starts after a payment fails.

Send an email.
Retry the charge.
Escalate urgency.

All good advice.

But none of it addresses the highest-leverage move in churn recovery:

Prevent the payment from failing in the first place.

The Real Problem: Expired Cards

The single biggest preventable cause of payment failure?

Expired credit cards.

~10–12% of all declines come directly from expired cards
~30% of cards are reissued annually (new number, same user)
Customers don’t update their details proactively
The next billing cycle hits → payment fails → dunning begins

By the time you enter dunning, you’re already reacting.

The Fix Is Stupidly Simple

Stripe already gives you everything you need.

Every PaymentMethod object contains:

const paymentMethod = await stripe.paymentMethods.retrieve('pm_xxx');

// paymentMethod.card.exp_month → 7
// paymentMethod.card.exp_year  → 2026
// paymentMethod.card.last4     → "4242"
// paymentMethod.card.brand     → "visa"

You just need to:

Pull all active subscribers
Check card expiry dates
Notify users before failure happens

Step 1: Find Expiring Cards

Here’s a working skeleton:

const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);

async function findExpiringCards() {
  const now = new Date();
  const currentMonth = now.getMonth() + 1;
  const currentYear = now.getFullYear();

  const target = new Date(now.getTime() + 30 * 24 * 60 * 60 * 1000);
  const targetMonth = target.getMonth() + 1;
  const targetYear = target.getFullYear();

  let hasMore = true;
  let startingAfter = null;
  const expiring = [];

  while (hasMore) {
    const params = { limit: 100, status: 'active' };
    if (startingAfter) params.starting_after = startingAfter;

    const subs = await stripe.subscriptions.list(params);

    for (const sub of subs.data) {
      const pm = sub.default_payment_method;
      if (!pm || typeof pm === 'string') continue;

      const { exp_month, exp_year, last4, brand } = pm.card;

      const expiresThisMonth =
        exp_year === currentYear && exp_month === currentMonth;

      const expiresNextMonth =
        exp_year === targetYear && exp_month === targetMonth;

      if (expiresThisMonth || expiresNextMonth) {
        expiring.push({
          customerId: sub.customer,
          subscriptionId: sub.id,
          last4,
          brand,
          exp_month,
          exp_year,
          email: null // fetch separately
        });
      }
    }

    hasMore = subs.has_more;

    if (subs.data.length > 0) {
      startingAfter = subs.data[subs.data.length - 1].id;
    }
  }

  return expiring;
}

Step 2: Give Them a Frictionless Fix

Don’t send users to login pages.
Don’t create unnecessary steps.

Generate a direct update link using Stripe Customer Portal:

async function getUpdateLink(customerId) {
  const session = await stripe.billingPortal.sessions.create({
    customer: customerId,
    return_url: 'https://yourapp.com/billing',
    flow_data: {
      type: 'payment_method_update',
    },
  });

  return session.url;
}

This link is:

Pre-authenticated
Short-lived
One-click → update → done

Step 3: The Email (Don’t Overthink It)

Plain text wins.

No templates. No branding. No fluff.

Subject: Your card ending in 4242 expires soon

Hey [name],

Quick heads up — the Visa ending in 4242 that you have on file for [product name] expires next month.

If you update it before your next billing date ([date]), everything stays seamless. Takes about 30 seconds:

[Update your card →]

If you've already received a new card from your bank, it likely has a different number even though the old one still works until expiry.

Thanks,  
[your name]

That’s it.

Step 4: Run It Daily

Set it up as:

Cron job
Scheduled function
Background worker

Cadence:

Day -30 → first email
Day -7 → reminder (optional)

Why This Works

You’re intercepting failure before it exists.

Compare:

Approach	Timing	Conversion Difficulty
Traditional dunning	After failure	High
Pre-expiry alert	Before failure	Low

The user hasn’t experienced a problem yet — so fixing it feels trivial.

Want This Without Building It Yourself?

If you’d rather not wire all of this up manually plus handle edge cases, reminders, and multiple recovery layers that’s exactly why I built SaveMRR.

It doesn’t just catch expiring cards.
It runs multiple recovery mechanisms in the background so you’re not leaking revenue silently every month.

🔍 What it does:

Pre-expiry detection (like the flow above)
Smart recovery sequences
Continuous monitoring of failed payments
Zero maintenance once set up

Pricing:

$19/month — built for bootstrapped SaaS founders

Free Revenue Scan:

Connects to Stripe (read-only access)
Uses restricted API keys
AES-256 encrypted
Shows exactly how much revenue you’re losing

Takes ~60 seconds.
No credit card required.

👉 https://savemrr.co

What About Stripe Account Updater?

Stripe’s Account Updater helps by:

Automatically updating card details when banks reissue cards

But:

It’s not universal
Depends on issuer + network support
Misses a non-trivial percentage

Pre-expiry emails cover the gap.

The Bottom Line

If you’re running a SaaS on Stripe and not doing this:

You are choosing to lose recoverable revenue every month.

This is not an optimization.
This is baseline infrastructure.

Final Take

Before you:

Optimize retry logic
Add more dunning emails
Build complex churn flows

Fix the simplest leak:

Catch expiring cards before they fail.

Everything else comes after.

Your SaaS is leaking money right now. Here's how to find it in 60 seconds.

houseofmvps — Wed, 15 Apr 2026 19:55:56 +0000

I’m going to show you something that most SaaS founders have never checked

It takes 60 seconds and it might ruin your morning.

Open your Stripe dashboard. Go to Payments. Filter by status: Failed. Set the date range to the last 90 days.

Add up the numbers.

That total?

That’s revenue you billed for but never collected. Customers who didn’t cancel their payments just broke. And unless you did something about each one individually, that money is gone.

I’ve been building a payment recovery tool

For the past few months, I’ve talked to dozens of SaaS founders.

Almost none of them had ever run this filter.

The number is usually between 5% and 12% of total billings.

On $20K MRR, that’s $1,000 to $2,400 every single month that silently disappears.

Why it happens

Subscription payments fail for a handful of reasons, and they’re more mundane than you’d expect.

Insufficient funds account for roughly 44–47% of all card declines.
This is the biggest bucket by far. The customer’s card is valid, they haven’t cancelled, they just don’t have enough balance on billing day. This is especially common with debit cards.

Fraud detection flags cause another 15–20%.
Most of these are false positives the bank’s algorithm flagged a recurring charge as suspicious. The customer has no idea this happened.

Expired or reissued cards make up about 10–12%.
Visa says roughly 30% of all cards get reissued in any given year. When that happens, the old card number on file stops working. Unless the customer proactively updates it (they won’t), the next charge fails.

The rest is a mix of card limits, incorrect details from card reissuance, processor errors, and the dreaded “do not honor” generic decline that issuers throw when they don’t want to tell you the real reason.

What Stripe does about it and what it doesn’t

Stripe has a feature called Smart Retries. If you’re on Stripe Billing, it’s on by default. It uses an ML model trained on hundreds of billions of data points across the entire Stripe network to figure out the best time to retry a failed charge.

The model considers over 500 signals card issuer patterns, time of day, day of week, customer activity, even debit card payday cycles.

It’s genuinely impressive engineering.

Stripe says it recovers $9 in revenue for every $1 spent on Billing.

But here’s what Smart Retries don’t do:

They don’t email your customer.
They don’t send an SMS.
They don’t alert you that a VIP account is past due.
They don’t warn a customer whose card is about to expire.
They don’t put up an in-app banner asking the customer to update their payment method.

Smart Retries handle the charge retry.

Everything else the outbound communication, the pre-dunning, the urgency creation, the one-click card update links is on you.

And “on you” usually means “doesn’t happen.”

The gap is where the money lives

The gap between what Stripe recovers automatically and what a proper dunning system recovers is where your lost revenue sits.

Third-party sources estimate Smart Retries alone recover somewhere around 38% of failed payments.

The best dedicated dunning systems push recovery to 50–70%, according to Churn Buster’s published data across their client base.

That 20–30 percentage point gap, applied to your specific failed payment volume, is the dollar amount you’re currently leaving on the table every month.

Here’s the math on a real SaaS business

$20,000 MRR

About 13% of recurring charges decline monthly (Recurly’s benchmark across 1,200 sites).

That’s $2,600/month in failed charges.

Stripe Smart Retries recover ~38%, getting back roughly $988.

The remaining $1,612 needs human-scale intervention:
an email, an SMS, a warning before the card expires.

A proper dunning system recovering at 55% would get back $1,430 — an incremental $442/month over Stripe alone.

That’s $5,304/year in revenue that was already yours, from customers who never wanted to leave.

What you can do right now, for free

Before you buy any tool, do three things:

First

Run that Stripe filter I mentioned.

Know your number.

It’s the most important metric in your business that you’re not tracking.

Second

Set up a webhook listener for invoice.payment_failed.

When it fires, send an email from your own domain
(not noreply@, not billing@ a real address that someone reads)

Include a link to Stripe’s Customer Portal where the customer can update their card.

You can generate a portal session URL via:

stripe.billingPortal.sessions.create()

Takes maybe an afternoon of work.

Third

Pull card expiry data from the Stripe API.

The PaymentMethod object has:

card.exp_month
card.exp_year

Write a daily cron that checks for cards expiring in the next 30 days and emails those customers a heads up.

This alone prevents a meaningful chunk of failures from ever happening.

If you want this fully automated

I built SaveMRR for exactly this use case.

$19/month for bootstrapped SaaS founders.

There’s a free Revenue Scan that:

Connects to your Stripe (read-only)
Uses restricted API keys
AES-256 encrypted
Shows you the exact dollar amount you’re losing

Takes 60 seconds. No credit card needed.

👉 https://savemrr.co

But honestly

Start with the Stripe filter.

The number will motivate everything else.

Slash 90% of Tokens Per Session With This Pre-Compiled Wiki (Karpathy Inspired Workflow)

houseofmvps — Thu, 09 Apr 2026 23:04:06 +0000

Last June, Karpathy posted something that got 2.3 million views. He said context engineering matters more than prompt engineering specifically, "the delicate art and science of filling the context window with just the right information for the next step."

Then last week he posted about building structured markdown knowledge bases that LLMs can reason over. Also went viral.

Both ideas point at the same problem: your AI is only as good as the context you give it. And right now, most of us are giving it terrible context.

the problem nobody's measuring

Every time you start a Claude Code session, it spends the first chunk of time just figuring out your project. Reading files. Grepping for routes. Opening package.json. Exploring the import graph. Finding your schema. Checking your env vars.

I started measuring how many tokens this costs. On a real 92-file monorepo (Hono + Drizzle, 4 workspaces): ~66,000 tokens. Every session. Not cached between sessions.

On a 53-file project: ~46,000 tokens. On a 40-file project: ~26,000.

That's your AI burning through your context window (the "RAM" in Karpathy's analogy) just to understand the project before it does anything you actually asked for.

what context engineering looks like in practice

If you follow Karpathy's framing, the solution is obvious: don't let your AI waste context exploring. Pre-compile the context it needs and hand it over at session start.

That's what I built. npx codesight scans your codebase via AST parsing and generates a structured context map (routes, schema, components, dependency graph, env vars, middleware, hot files)in one markdown file your AI reads immediately.

npx codesight

One command. Zero dependencies. It borrows TypeScript from your own node_modules for the compiler API. Falls back to regex for non-TS projects.

the numbers

Real production codebases. Not toy demos.

Project	Files	codesight Output	Manual Exploration	Reduction
SaaS A (Hono + Drizzle monorepo)	92	5,129 tokens	~66,040 tokens	12.9x
SaaS B (raw HTTP + Drizzle)	53	3,945 tokens	~46,020 tokens	11.7x
SaaS C (Hono + Drizzle, 3 workspaces)	40	2,865 tokens	~26,130 tokens	9.1x

Average: 11.2x. Your AI reads 3-5K tokens of structured context instead of burning 26-66K tokens exploring.

why AST matters

Regex-based tools guess at your code structure. AST parsing actually understands it.

When TypeScript is in your project, codesight uses the real TypeScript compiler API. This means:

Follows router.use('/prefix', subRouter) chains (regex misses nested routers)
Combines NestJS @Controller('users') + @Get(':id') into /users/:id
Parses tRPC router({ users: userRouter }) nesting correctly
Extracts Drizzle field types from .primaryKey().notNull() chains
Detects middleware in route handler chains: app.get('/path', auth, handler)
Filters out false positives like c.get('userId') that regex would match as routes

Zero false positives across all three benchmark projects.

25+ frameworks detected. 8 ORMs parsed. React/Vue/Svelte components with props.

blast radius — context engineering for changes

Karpathy's framing isn't just about initial context. It's about giving your AI the right information for "the next step." When the next step is changing a file, your AI needs to know what breaks.

npx codesight --blast src/db/index.ts

BFS through the import graph. Shows every transitively affected file, route, and model.

On BuildRadar, changing the database module correctly identified 10 affected files, 33 routes, and all 12 models. Three hops deep.

Your AI reads this before touching the file. That's context engineering applied to refactoring.

the wiki layer (Karpathy's latest idea, automated)

Karpathy's April 3rd post was about structured markdown wikis that LLMs can reason over. codesight v1.6.2 added --wiki which does exactly this for your codebase:

npx codesight --wiki

It generates a wiki knowledge base in .codesight/wiki/ — an index.md (200 tokens) plus individual articles per topic. Your AI reads the index at session start, then pulls the one relevant article for each question.

Without codesight: AI reads 26-66K tokens exploring.
With codesight: AI reads 3-5K tokens (the full map).
With --wiki: AI reads ~200 tokens at start, then ~160-350 per question.

Combined reduction: ~91x.

it generates context for everything

One command creates context files for every major AI tool:

npx codesight --init

CLAUDE.md for Claude Code
.cursorrules for Cursor
codex.md for OpenAI Codex
AGENTS.md for Codex agents
.github/copilot-instructions.md for GitHub Copilot

Each pre-filled with your actual project structure.

MCP server mode

npx codesight --mcp

Runs as a Model Context Protocol server. Your AI queries specific context on demand instead of loading everything. Session caching — first call scans, subsequent calls return instantly.

the relationship to caveman mode

The caveman prompt trick reduces output tokens (what the AI says back).

codesight reduces input/exploration tokens (what the AI reads to understand your project).

Caveman = make the AI talk less.
codesight = give the AI exactly what it needs to know.

They're complementary. Use both.

try it

npx codesight

Zero deps. MIT. ~200ms scan time. Works with any Node.js project (and has regex fallback for Python, Go, Ruby, Rust, Java, Kotlin, Elixir, PHP).

(https://github.com/Houseofmvps/codesight)

If it saves you tokens, a star helps others find it too.

Karpathy defined the skill. This tool automates it.

Built by Kailesk Khumar, solo founder of houseofmvps.com.