DEV Community: Troy Johnston

The JavaScript Logic Behind Tracking 14 Credit Card APR Deadlines (Without Losing Your Mind)

Troy Johnston — Fri, 17 Apr 2026 20:17:10 +0000

I run 14 credit cards simultaneously.

Not because I'm reckless — because I understand how to use 0% APR introductory periods as free short-term financing. Done right, it's a legitimate way to smooth cash flow, fund purchases, or carry a balance for 12-21 months without paying a cent in interest.

Done wrong — miss one deadline — and you're looking at retroactive interest charges that can wipe out months of careful management.

This is the problem I set out to solve with code.

The Core Problem: Date Math Is Harder Than It Looks

Every 0% APR card has a deadline. But the deadline isn't just "the date on the agreement." It's a function of:

When the card was approved (not always when you first used it)
The promotional period length (12, 15, 18, or 21 months)
The exact billing cycle the promotion ends on

Here's the naive approach most people take:

// Don't do this
const deadline = new Date(approvalDate);
deadline.setMonth(deadline.getMonth() + promoMonths);

The problem? This doesn't account for billing cycles. Your card's promotional period ends on a statement date, not the anniversary of approval. If your billing cycle closes on the 15th and your promo ends "after 12 months," you might actually have until the 15th of the 13th month — or you might lose the promo two weeks earlier than you thought.

A More Reliable Model

Here's the logic I built to handle this properly:

function getAprDeadline(approvalDate, promoMonths, cycleClosingDay) {
  const approval = new Date(approvalDate);

  // Calculate raw deadline
  const rawDeadline = new Date(approval);
  rawDeadline.setMonth(rawDeadline.getMonth() + promoMonths);

  // Find the billing cycle close BEFORE the raw deadline
  const deadlineMonth = rawDeadline.getMonth();
  const deadlineYear = rawDeadline.getFullYear();

  const cycleClose = new Date(deadlineYear, deadlineMonth, cycleClosingDay);

  // If cycle closing day is after raw deadline, use the previous cycle
  if (cycleClose > rawDeadline) {
    cycleClose.setMonth(cycleClose.getMonth() - 1);
  }

  return cycleClose;
}

// Usage
const deadline = getAprDeadline('2023-11-15', 15, 8);
console.log(deadline.toDateString()); // The actual safe payoff date

This gives you the last billing cycle close before the promotion expires — which is the date your balance needs to hit zero.

Adding Alert Thresholds

Knowing the deadline is step one. The second piece is tiered alerts. I set three:

function getAlertStatus(deadline) {
  const today = new Date();
  const daysLeft = Math.ceil((deadline - today) / (1000 * 60 * 60 * 24));

  if (daysLeft <= 30) return { level: 'CRITICAL', daysLeft };
  if (daysLeft <= 60) return { level: 'WARNING', daysLeft };
  if (daysLeft <= 90) return { level: 'HEADS_UP', daysLeft };
  return { level: 'OK', daysLeft };
}

And here's where it gets useful at scale — looping over all cards and sorting by urgency:

const cards = [
  { name: 'Chase Freedom Flex', approvalDate: '2023-06-01', promoMonths: 15, cycleClosingDay: 22 },
  { name: 'Citi Simplicity', approvalDate: '2023-09-10', promoMonths: 21, cycleClosingDay: 14 },
  { name: 'Wells Fargo Reflect', approvalDate: '2024-01-05', promoMonths: 21, cycleClosingDay: 3 },
  // ... 11 more
];

const dashboard = cards
  .map(card => ({
    ...card,
    deadline: getAprDeadline(card.approvalDate, card.promoMonths, card.cycleClosingDay),
  }))
  .map(card => ({
    ...card,
    alert: getAlertStatus(card.deadline),
  }))
  .sort((a, b) => a.deadline - b.deadline);

dashboard.forEach(card => {
  const { level, daysLeft } = card.alert;
  console.log(`[${level}] ${card.name}: ${daysLeft} days left (deadline: ${card.deadline.toDateString()})`);
});

Output looks like:

[CRITICAL] Chase Freedom Flex: 23 days left (deadline: Mon Apr 28 2026)
[WARNING] Citi Simplicity: 47 days left (deadline: Fri May 22 2026)
[OK] Wells Fargo Reflect: 112 days left (deadline: Mon Jul 27 2026)

The Minimum Payment Problem

Here's a trap I see developers fall into when building this kind of tracker: they focus on the deadline, not the minimum payment.

Even with a 0% APR card, you must make minimum payments every month. Miss one, and many issuers will immediately terminate your promotional rate. So the dashboard needs to track two separate things per card:

APR deadline — when the full balance must be paid
Next minimum payment due — monthly, non-negotiable

I added a second layer to the data model:

const card = {
  name: 'Chase Freedom Flex',
  approvalDate: '2023-06-01',
  promoMonths: 15,
  cycleClosingDay: 22,
  currentBalance: 4800,
  minimumPaymentDue: '2026-04-28',
  minimumPaymentAmount: 35,
};

And a function that calculates the monthly paydown needed to hit zero before deadline:

function getRequiredMonthlyPayment(balance, deadline) {
  const today = new Date();
  const monthsLeft = (deadline.getFullYear() - today.getFullYear()) * 12 
    + (deadline.getMonth() - today.getMonth());

  if (monthsLeft <= 0) return balance; // Pay it all now
  return Math.ceil(balance / monthsLeft);
}

// Result: how much to pay each month to clear the balance in time
console.log(getRequiredMonthlyPayment(4800, deadline)); // e.g., "$200/month"

What I Learned (And What I Eventually Used)

After building this out, I realized maintaining the logic for 14 cards manually — with JSON files, cron jobs for alerts, and hand-updated billing cycles — was its own part-time job.

I eventually found StackEasy, which handles this whole layer for you: tracks APR windows, sends deadline alerts, and shows the monthly paydown math without requiring you to maintain the underlying code.

But the exercise of building it myself first was worth it. I understood the edge cases: what happens when a promotional rate ends mid-cycle, how grace periods affect payoff timing, why the "months remaining" counter on most apps is an oversimplification.

If you're building something similar, the key insight is: the deadline isn't a date — it's a billing cycle. Model it that way from the start and you'll avoid a lot of pain.

The Full Pattern

For anyone who wants to build their own version, here's the complete minimal tracker:

class AprTracker {
  constructor(cards) {
    this.cards = cards;
  }

  getDeadline(card) {
    const approval = new Date(card.approvalDate);
    const raw = new Date(approval);
    raw.setMonth(raw.getMonth() + card.promoMonths);

    const cycle = new Date(raw.getFullYear(), raw.getMonth(), card.cycleClosingDay);
    if (cycle > raw) cycle.setMonth(cycle.getMonth() - 1);
    return cycle;
  }

  getDaysLeft(deadline) {
    return Math.ceil((deadline - new Date()) / 86400000);
  }

  getMonthlyPaydown(balance, deadline) {
    const today = new Date();
    const months = (deadline.getFullYear() - today.getFullYear()) * 12
      + (deadline.getMonth() - today.getMonth());
    return months > 0 ? Math.ceil(balance / months) : balance;
  }

  report() {
    return this.cards.map(card => {
      const deadline = this.getDeadline(card);
      const daysLeft = this.getDaysLeft(deadline);
      const monthly = this.getMonthlyPaydown(card.balance, deadline);
      return { name: card.name, deadline, daysLeft, monthly };
    }).sort((a, b) => a.daysLeft - b.daysLeft);
  }
}

const tracker = new AprTracker(cards);
console.table(tracker.report());

Drop this in a cron job with a Slack webhook and you have a functional APR deadline system.

Happy to share the full implementation with cron scheduling and Slack alerts if there's interest — let me know in the comments.

How I Built a Credit Card Management Dashboard (And Why Spreadsheets Were Not Cutting It)

Troy Johnston — Tue, 03 Mar 2026 02:56:36 +0000

I had 17 credit cards open. Each one had a purpose. 0% APR on a balance transfer expiring in four months. A business card earning 3x on advertising. A personal card with rotating 5% categories. Another business line I used specifically for inventory purchases.

I tracked all of this in a Google Sheet. Columns for card name, issuer, credit limit, current balance, APR, promo rate, promo expiration date, annual fee date, reward structure, and notes. Color-coded rows for urgency. Conditional formatting that was supposed to flag upcoming deadlines.

It worked for about two years. Then it stopped working.

The Breaking Point

I missed a 0% APR expiration on a card carrying a $12,000 balance. The promotional rate ended on a Tuesday. I did not check the spreadsheet that week. The standard APR kicked in. By the time I noticed, I owed interest I never needed to pay.

The spreadsheet had the date in it. The conditional formatting was set up correctly. The problem was not the data. The problem was that a spreadsheet does not tap you on the shoulder and say "hey, you have 7 days before this rate expires and you still have $12,000 on this card."

That was the moment I decided to build something better.

What I Actually Needed

Before writing any code, I wrote down the things that had gone wrong over two years of spreadsheet-based card management:

No proactive alerts. The spreadsheet shows data. It does not push notifications. I had to remember to check it, and I did not always remember.
Utilization was manual math. Calculating total credit utilization across 17 cards meant updating balances, summing them, dividing by total limits. Every time.
No "which card should I use" logic. I knew the reward structures in my head, mostly. But I regularly used the wrong card at the wrong merchant because I was not thinking about it in the moment.
Annual fee decisions were reactive. I would notice the fee on my statement instead of evaluating whether to keep the card before the fee hit.
Application tracking was a mess. Am I under Chase's 5/24? When was my last application with Amex? I had to count manually.

The Technical Approach

I am not going to pretend this needed bleeding-edge technology. The core problem is data management and timely notifications. Here is what mattered:

Data Model

Every credit card is an object with these core properties:

- Card name / issuer
- Credit limit
- Current balance (manual or API-synced)
- Standard APR
- Promotional rate (if any)
- Promotional rate expiration date
- Annual fee amount
- Annual fee date
- Reward structure (categories + multipliers)
- Application date
- Last statement date
- Payment due date

The tricky part is that some of these properties are time-dependent. A card's effective APR changes when the promo expires. Reward categories rotate quarterly. Annual fees create decision points that need to be surfaced before the charge hits.

Deadline Engine

The most important feature. Every card generates a set of deadlines:

Promo rate expiration (alert at 90, 60, 30, 7 days)
Annual fee renewal (alert at 60 and 30 days before)
Payment due date (alert at 7 and 3 days before)
Rotating category activation windows

Each deadline has a severity level and an associated action. "Your Citi card's 0% APR expires in 30 days. Current balance: $8,400. Action: pay off or transfer." That context is what a spreadsheet cannot provide.

Utilization Calculator

Real-time (or near-real-time) calculation of:

Total utilization across all cards
Per-card utilization
Utilization impact if you move a balance from Card A to Card B

This sounds simple, but it becomes genuinely useful when you are deciding whether to put a $3,000 purchase on your Chase card (pushing that card to 45% utilization) or your Amex (which stays at 12%). The per-card utilization matters for your credit score, not just the total.

Card Selector

Given a spending category (groceries, gas, dining, online, etc.), which card in your portfolio earns the best return? This requires knowing:

Base reward rate per card
Bonus categories per card (including rotating quarterly bonuses)
Whether quarterly bonuses have been activated
Any spending caps on bonus categories

It is essentially a lookup function, but one that changes quarterly and needs to account for caps and activation status.

What I Learned Building This

Financial data is messy

Credit card terms are not standardized. One issuer calls it "promotional APR." Another calls it "introductory rate." The expiration logic varies. Some promos end on a specific date. Others end "18 months after account opening," which means you need to calculate the date from the application date.

People do not update manually

I built the first version with manual balance entry. Nobody used it consistently. The dashboard was only useful when the data was current, and manual data entry creates a chicken-and-egg problem. I had to find ways to minimize manual input or make it frictionless.

Notifications are the product

The dashboard is nice. The charts are helpful. But the thing that actually prevents expensive mistakes is the notification that arrives three days before a promo rate expires. Everything else is secondary to that alert engine.

YMYL content requires extreme care

Building in the financial space means your content is classified as "Your Money, Your Life" by search engines. Google holds YMYL content to a higher standard. Every number needs to be accurate. Every claim needs to be defensible. You cannot publish sloppy financial advice and expect to rank.

Current State

StackEasy is live and people are using it. The core features that matter most:

Portfolio dashboard showing all cards, balances, limits, and utilization at a glance
Deadline tracker with proactive alerts for promo expirations, annual fees, and payment dates
Card selector that recommends the best card for each spending category
Application log that tracks your velocity across issuers

The biggest validation was when users told me they caught a promo expiration they would have missed. That is the whole point. Not the charts, not the UI polish. Did you avoid losing money you did not need to lose?

For Other Builders

If you are thinking about building in fintech, here are the non-obvious lessons:

Start with your own pain. I built StackEasy because I needed it. That meant I understood the edge cases before writing a single line of code.
Management tools are undervalued. Everyone builds tools to help people find or buy financial products. Almost nobody builds tools to help people manage what they already have.
Simple beats clever. A deadline alert that fires on time is worth more than a machine learning model that predicts spending patterns.
Trust is everything. People are entering their financial data. Earn that trust through transparency, security, and never being clever with their information.

If you are managing multiple credit cards and a spreadsheet is starting to crack, check out StackEasy. Happy to answer questions about the build in the comments.

Using Automation to Track 0% APR Deadlines Across 20 Credit Cards

Troy Johnston — Tue, 03 Mar 2026 02:40:05 +0000

Here is a number that should bother you: the average credit card APR in 2026 is north of 20%. If you are carrying a balance on a promotional 0% APR offer and that promotion expires without you noticing, your effective interest rate jumps from zero to twenty-something percent overnight.

On a $10,000 balance, that is roughly $170 per month in interest you were not paying yesterday.

This is the single most expensive failure point in credit card management. And it happens to smart people constantly because tracking promotional rate expirations manually is a system designed to fail.

The Problem

I manage a portfolio of credit cards for both personal and business use. At any given time, I might have 4-6 cards with active 0% APR promotions. Some are balance transfers. Some are purchase promotions. Each one has a different expiration date.

Here is what a typical month looks like:

Card A (Chase)     | 0% APR Purchase    | Expires: June 15, 2026    | Balance: $4,200
Card B (Citi)      | 0% Balance Transfer| Expires: October 3, 2026  | Balance: $8,500
Card C (Amex)      | 0% APR Purchase    | Expires: March 28, 2026   | Balance: $2,100
Card D (Discover)  | 0% Balance Transfer| Expires: August 22, 2026  | Balance: $6,000
Card E (US Bank)   | 0% APR Purchase    | Expires: April 10, 2026   | Balance: $3,300

Five cards. Five different expiration dates. Total exposure: $24,100 in balances that will start accruing interest at 20%+ if I miss any of these dates.

The traditional approach: put these dates in a calendar. Set reminders. Check a spreadsheet. Hope you do not miss one during a busy week.

The problem: you will miss one during a busy week. I know because I did.

Why Calendar Reminders Are Not Enough

A calendar reminder says "Card C promo expires March 28." That is data without context. Here is what you actually need to know when a promo is about to expire:

Current balance on the card - Is it $200 or $12,000? The urgency is completely different.
Can you pay it off before expiration? - If you have 30 days and the balance is $8,000, do you have $8,000 available?
Can you transfer the balance? - Do you have another card with a 0% balance transfer offer available?
What is the fallback APR? - Some cards go to 15%. Some go to 25%. The cost of missing this deadline varies by card.
What are your other upcoming expirations? - If three promos expire within 60 days of each other, you need a plan, not a reminder.

A smart notification system provides all of this in the alert itself. A calendar event provides none of it.

The Data Model

Every promo period needs these fields:

{
  cardId: "chase-freedom-flex",
  promoType: "purchase_apr",     // or "balance_transfer_apr"
  promoRate: 0,                  // the promotional APR (usually 0)
  standardRate: 22.49,           // what it reverts to
  startDate: "2025-06-15",
  endDate: "2026-06-15",
  currentBalance: 4200,          // needs regular updates
  minimumPayment: 42,
  isActive: true
}

From this data, you can derive:

Days remaining: Simple date math
Monthly interest if promo lapses: currentBalance * (standardRate / 12)
Payoff amount per month: currentBalance / monthsRemaining
Urgency tier: Based on days remaining and balance

The Notification Logic

Not all deadlines are created equal. A card with a $200 balance expiring next month does not need the same urgency as a card with $10,000 expiring in two weeks. The notification system needs tiers:

Tier 1: Informational (90-60 days out)

A gentle heads up. "Your Chase card's 0% APR expires in 78 days. Current balance: $4,200. At this point, paying $1,400/month would eliminate the balance before the promo ends."

No panic. Just awareness and a path forward.

Tier 2: Planning (60-30 days out)

More urgent. Include options. "Your Citi card's 0% balance transfer rate expires in 45 days. Current balance: $8,500. Options: (1) Pay $4,250/month to clear it, (2) Transfer to a new 0% card, (3) Accept the standard rate of 21.99%."

This is where most people need to make a decision.

Tier 3: Action Required (30-7 days out)

This is the "do something now" alert. "Your Amex 0% APR expires in 12 days. Balance: $2,100. Monthly interest at standard rate: $38.50. Pay off now to avoid charges."

Tier 4: Critical (Under 7 days)

Daily alerts. "TOMORROW: Your Discover 0% balance transfer rate expires. Current balance: $6,000. Standard APR: 23.99%. This will cost approximately $120/month in interest if not addressed."

The Cascade Problem

Here is what makes this genuinely complex. Promo expirations do not happen in isolation. If three cards lose their promotional rates within the same quarter, you might face $15,000+ in balances suddenly accruing interest. The system needs to model these cascades.

March 28:  Card C expires -> $2,100 starts accruing at 22%
April 10:  Card E expires -> $3,300 starts accruing at 20%
June 15:   Card A expires -> $4,200 starts accruing at 24%

Total cascade exposure (Q2): $9,600
Combined monthly interest if all three lapse: ~$165/month

When the system sees this pattern 90 days out, it should surface it as a strategic alert, not three separate notifications. "You have $9,600 in promotional balances expiring between March and June. Here is a prioritized payoff plan."

Utilization Side Effects

Paying off balances changes your credit utilization. If you aggressively pay down $9,600 in balances before promos expire, your total utilization drops. That is good for your credit score. But if you transfer balances to consolidate, your per-card utilization on the receiving card spikes. That could hurt your score.

The automation needs to model these tradeoffs:

Option A: Pay off Card C ($2,100) and Card E ($3,300) directly.
  - Total utilization drops from 28% to 19%
  - Cash flow impact: $5,400 over 6 weeks

Option B: Transfer Card C balance to Card F (new 0% BT offer).
  - Card F utilization goes from 0% to 21%
  - No immediate cash flow impact
  - Extends the 0% window by 15 months

Both options are valid. The right choice depends on the person's cash flow, credit score goals, and whether they have a new 0% offer available. The system presents the math. The person makes the call.

What I Built

This is all baked into StackEasy. The tiered notification system, the cascade detection, the utilization modeling. It is the feature I am most proud of because it directly prevents the most expensive mistake credit stackers make.

The dashboard shows:

All active promo periods on a timeline
Days remaining with color-coded urgency
Projected interest cost if the promo lapses
Available balance transfer options from your existing portfolio
Utilization impact of different payoff strategies

Lessons for Other Developers

If you are building anything that involves time-sensitive financial events:

Context in notifications beats raw data every time. "Card expires March 28" is useless. "Card with $8,500 balance expires in 12 days, costing $156/month if missed" drives action.
Model interactions between events. Financial decisions cascade. A single-event view misses the bigger picture.
Make the math visible. People trust systems that show their work. "Here is the interest calculation" builds more confidence than "Alert: take action now."
Default to conservative. In financial tools, a false positive (alerting when unnecessary) is always better than a false negative (missing a real deadline).
Date math is deceptively complex. "18 months from account opening" sounds simple until you account for weekends, statement cycles, and issuer-specific grace periods.

If you are managing multiple credit cards with promotional rates and want to stop worrying about missed deadlines, StackEasy was built for exactly this. Happy to discuss the implementation details in the comments.