Category Archives: webdev

JavaScript, webdev

Building PowderCast: The Ultimate Open Source Weather App for Snowboarders 🏂

If you know me, you know I love two things: writing code that solves real problems, and shredding fresh powder.

For years, I’ve been frustrated with generic weather apps. You know the struggle – the app says “partly cloudy and 30°F” for the town near the resort, but when you get to the summit, it’s a whiteout with 50mph gusts and wind-hold on every lift.

The delta between “base village weather” and “summit weather” can be the difference between the best day of your season and a frostbitten disaster.

So, I did what any engineer would do:

I built my own solution: PowderCast.

Continue reading →
Standard
bots, Business, JavaScript

Streamline Engineering Updates with Slack to Notion Bot

There’s been a lot of noise lately about productivity tools and the “perfect” engineering workflow.
Let’s slow down and separate what actually works from what just creates more overhead.

Here’s a boring truth: Slack is incredible for quick, ephemeral communication.
Here’s a less comfortable truth: It is an absolute nightmare as a system of record.

If you lead an engineering team or run a startup, you probably have a #daily-updates or #eod-reports channel.
The theory is sound.

Everyone drops a quick note at the end of the day: what they shipped, what blocked them, what’s next.

But here is what actually happens:

Those updates get posted.
Someone replies with an emoji.
A thread erupts about a weird bug in production.
Someone posts a picture of their dog.

By Friday, when you’re trying to answer a simple question—“What did we actually accomplish this week?”—those reports are buried under a mountain of noise.

You find yourself scrolling endlessly.
It’s exhausting.
And it doesn’t scale. Not to mention that if you will need SOC-2 (and you will 🙂 ) –> you can’t say “we have everything in Slack”

Why not just force everyone into Jira or Linear?

You could.
But engineers hate context-switching just to write a status update.
Slack is where the conversation is happening.
The friction to post there is zero.

The problem isn’t the input. The problem is the storage.

So I (=Gemini+Claude) built a bridge.

Meet the Slack → Notion EOD Sync Bot

I got tired of losing track of momentum, so I wrote a bot that does the tracking for us.

It’s a lightweight NodeJS service that automatically extracts End-of-Day reports from Slack and structures them beautifully in a Notion database.

Continue reading →
Standard
AI, webdev

Maximize Productivity in Your Codebase with gemini-cli

If you’ve ever opened a legacy project and felt your soul briefly leave your body, this one’s for you.

You know the scene:

  • 200k+ lines of code
  • Three architectural “eras” living in the same repo
  • Tests that pass… somehow
  • A PR review queue that feels like airport security

Let’s fix that.

This post is a practical, hands-on guide to using gemini-cli as a serious productivity multiplier — not as a gimmick, not as a toy, but as a real engineering tool you can plug into your daily workflow today. Btw, I’m not ‘with’ Google for many years now… so it’s all my personal thoughts.

By the end, you’ll know exactly how to:

  • Explore massive codebases without losing your mind
  • Refactor safely and confidently
  • Pre-review your own PRs
  • Generate useful tests (not garbage)
  • Debug failures faster
  • Automate repetitive dev work
Continue reading →
Standard
Business, webdev

Stay Ahead of Cyber Threats with CISA Advisory Monitor

Here’s a boring truth:
Cybersecurity and Infrastructure Security Agency publishes critical cybersecurity advisories.

Here’s a less comfortable truth:
Most teams never check them.

CISA maintains the Known Exploited Vulnerabilities (KEV) catalog. These are not “theoretical risk under certain lab conditions” bugs. These are vulnerabilities attackers are actively exploiting in the wild, right now, against real systems.

When something lands in KEV, it’s not a polite suggestion. It’s a flare in the sky that says: patch this, or prepare for visitors.

And yet—no one wakes up thinking, “Before coffee, let me refresh a federal website.”

We’re building product.
We’re shipping features.
We’re arguing in Slack.
We’re trying to remember where that one Terraform variable is defined.

So I built a bot that does the refreshing for us.

Continue reading →
Standard
AI, Chrome, webdev

Transforming Recipe Chaos with SeasonApp

Some projects start with ambition.

This one started with annoyance.

I was tired of juggling recipes across bookmarks, screenshots, messages, and the occasional scribble in a notes app.
A normal person would’ve organized things.
I opened Cursor.

The plan was simple: a quick weekend hack.
Nothing serious. Just a tiny tool to help me stop losing recipes.

But then it worked. And I liked using it.
Then I showed it to a couple of friends.
Then my family started using it.
Then those friends shared it with their friends.

That’s when the “weekend hack” quietly transformed into SeasonApp—a small but mighty full-stack platform for cooking, powered by AI and built to remove friction from the kitchen.

Why SeasonApp Exists

If you cook regularly, your digital life eventually turns into a disorganized pantry. Tabs everywhere. Screenshots mixed with flight confirmations. Recipe blogs where you scroll past a childhood memoir before finding the ingredient list. And once you finally want to cook something, you can’t find the right recipe—or you’re missing one ingredient and the whole plan collapses.

SeasonApp brings order to that chaos.

It gives recipes a home.
It helps you create new ones.
And it actually understands what you want to do with whatever’s in your fridge.

The more people around me used it, the more obvious the need felt.
Everyone had the same pain; they just tolerated it.
SeasonApp gives them a better way.

Continue reading →
Standard
AI, webdev

8 Top Tips to Actually Use Cursor (Without Setting Your Wallet on Fire)

If you’ve been coding anytime in the past year, you’ve probably heard the buzz about Cursor — the AI-powered IDE that promises to write your code, clean your code, and maybe even refactor your soul.

It’s built on top of VS Code, so it feels instantly familiar.
But the moment you hit that shiny AI shortcut, you realize: this thing is smarter than your codebase and hungrier than your wallet.

After a few months of using Cursor — and after accidentally vaporizing a scandalous number of API tokens — I’ve learned how to stay productive and solvent.
And yes, the TL;DR is that you can still combine Cursor with Ollama + local models to get many of these benefits for free.
Here are my 8 hard-earned tips to make Cursor your loyal sidekick within the limits of your budget.

The #1 tip: Control context scope aggressively – This is the biggest win

Cursor auto-includes files, diffs, and history—this explodes token usage.

Do this:

  • Manually select only the exact files/functions needed
  • Avoid “entire repo” context unless absolutely required
  • Use @file and @selection instead of implicit context
  • Clear chat or start a new thread when switching tasks

Why it matters:
Token cost scales with every line in context, not just your prompt.

Below are a bit more tips:

Continue reading →
Standard
Chrome, JavaScript, webdev

Building a Real-Time Pull-Up Tracker: How I Taught The Browser to Count Our Pain

It started as a simple idea my son brought up: Can we make a web app that counts our pull-ups during our pull-up games?

Turns out, teaching a machine to recognize human suffering is both hilarious and complicated.
What began as a “let’s make a quick pull-ups app” spiraled into an intense journey through computer vision, browser quirks, and a few accidental infinite loops that made our laptop sound like a jet engine.

The “Simple” Goal

I wanted to automatically count pull-ups using a web camera.

Easy, right?

Just detect a human, see when they go up and down, and count.

Continue reading →
Standard
cloud, webdev

5 Essential Security Moves Every Startup & SMB Must Make to Prevent Cyber Attacks

If you’re working at a startup or SMB, you might think “we’re too small to be targeted.” You might believe that cyber attackers only go after Fortune 500 companies with deep pockets and valuable data worth millions.

That assumption could destroy your business.

Here’s the uncomfortable truth: attackers don’t discriminate by company size.
They discriminate by vulnerability.
And right now, small and medium-sized businesses represent the softest, most lucrative targets in the entire threat landscape.

Here are the top 5 things you should do.
Right now.

Continue reading →
Standard
cloud, Design, JavaScript, webdev

Building Resilient Microservices for Bootstrapped Apps 🏃🏼‍♀️🚵🏼

Out on the trail, your phone isn’t plugged into a wall. Every network ping drains battery. Every background process steals CPU cycles that could keep your GPS running for another hour.

In my previous post on the GPX Water Mapper, we explored visualizing water sources along your route. Now we’re going under the hood: designing a microservices architecture that respects the constraints of outdoor apps—where a dead battery isn’t just inconvenient, it’s potentially dangerous.

Imagine getting a real-time hydration alert as you approach mile 12 of your desert bike ride, calculated from your current pace, the temperature, and known water sources ahead.
All while using less battery than a typical podcast app.

What we’ll build:

  • A microservices approach that actually makes sense for small teams
    (spoiler: not everything needs to be a service – moreover, in many cases you should avoid it and run on a monolith)
  • Event-driven patterns that keep your app responsive without constant polling
  • Node.js implementations you can deploy on minimal infrastructure
  • Real-world trade-offs: when to split services and when a monolith wins
Continue reading →
Standard
Business, webdev

Scaling Engineering Teams: Lessons from Google, Facebook, and Netflix

After spending over a decade in engineering leadership roles at some of the world’s most chaotic innovation factories—Google, Facebook, and Netflix—I’ve learned one universal truth: scaling engineering teams is like raising teenagers. They grow fast, develop personalities of their own, and if you don’t set boundaries, suddenly they’re setting the house on fire at 3am.

The difference between teams that thrive at scale and those that collapse into Slack-thread anarchy typically comes down to three key factors:

  • Structured goal-setting
  • A ruthless focus on code quality
  • Intentional culture building

Let me share some lessons I learned from scaling teams at Google, Facebook, and Netflix. Here are a few frameworks, metrics, and tools that actually work when you’re trying to scale from 10 to 100 to 1,000+ engineers—without losing your mind or your best people.

Continue reading →
Standard