How I built self-destructing notes with AES-256-GCM and Upstash Redis

Michael Bello — Mon, 23 Feb 2026 10:04:55 +0000

Every developer has sent credentials over Slack. The other person copies the key and it sits in chat history forever, in Slack's logs, backups, search indexes.

I built notenotfound to fix this. Here's how the encryption and burn-after-reading works.

Encryption (AES-256-GCM)

function encrypt(plaintext) {
  const key    = crypto.createHash("sha256").update(ENCRYPTION_KEY).digest();
  const iv     = crypto.randomBytes(12);   // random 96-bit IV per note
  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
  const enc    = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
  const tag    = cipher.getAuthTag();      // 128-bit auth tag — tamper-proof
  return [iv, tag, enc].map(b => b.toString("hex")).join(":");
}

GCM mode means the auth tag detects any tampering. I chose SHA-256 for key derivation because scryptSync hit Netlify's serverless CPU limits.

The burn-after-reading

Two steps: (1) confirm=false checks note exists, returns metadata, note untouched. (2) confirm=true decrypts first, THEN deletes, then returns content. If decrypt fails, note stays in Redis. User gets an error and can retry — note never silently disappears.

The name

notenotfound, because that's exactly what happens to your note after it's read.

Live: notenotfound.netlify.app | Code: github.com/mykelayo/notenotfound

I built a free cron expression decoder, here's how it works under the hood

Michael Bello — Sun, 22 Feb 2026 16:05:15 +0000

The problem

Every developer has been here: you're staring at 0 */4 * * 1-5 in a config file
and you have no idea what it means without running it mentally or Googling it.

I got tired of that. So I built Cron.Explain, a free tool that decodes any cron expression into plain English instantly.

🔗 https://timely-flan-0ca3c1.netlify.app

What it does

Paste any cron expression and you get three things:

1. Plain English explanation
0 9 * * 1-5 → "At 9:00 AM, on Monday through Friday"

2. Field-by-field breakdown
Each of the 5 fields explained individually — minute, hour, day of month, month, day of week.

3. Next 5 run times
The actual dates and times your job will fire next, calculated in your local timezone.

The API

It also ships a free REST API — no key required:

curl -X POST https://timely-flan-0ca3c1.netlify.app/api/explain \
  -H "Content-Type: application/json" \
  -d '{"cron": "0 9 * * 1-5"}'

Response:

{
  "expression": "0 9 * * 1-5",
  "explanation": "At 9:00 AM, on Monday through Friday",
  "fields": { ... },
  "nextRuns": ["2026-02-23T09:00:00.000Z", ...]
}

How I built it

The interesting part: I didn't use any external cron parsing libraries.
The entire parser is hand-rolled in vanilla JavaScript.

The core is a matchesField(value, n, min) function that handles all the special cron characters: *, */n, n-m, n,m, and n/m.

The next-run calculator works by starting from the current minute and incrementing forward, checking each minute against all 5 fields until it finds 5 matches. It caps at 500,000 iterations to handle edge cases like rare monthly schedules.

Tech stack

React + Vite (frontend)
Netlify Functions (serverless API)
Zero dependencies for the parser
IBM Plex Mono font because it felt right for a dev tool

What's next

I'm thinking about adding:

Cron job monitoring (ping a URL, alert if it hasn't run)
Reverse builder (describe a schedule in English, get the cron)
More languages in the API docs

The code is open source on GitHub. Would love feedback, especially on cron expressions that break the parser — there are definitely edge cases I haven't covered.

🔗 Live tool: https://timely-flan-0ca3c1.netlify.app
📖 API docs: https://timely-flan-0ca3c1.netlify.app/docs

DEV Community: Michael Bello