Category Archives: webdev

AI, webdev

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

TL;DR

Open a new agent/chat for each new request or task, instead of continuing everything in one long conversation.

Keeping unrelated work in a single long chat makes the agent less efficient, increases context noise, and also becomes more expensive because the full conversation history keeps getting processed.

Best practice:

  • One request / task = one new agent
  • Keep chats focused on a single issue or feature
  • Start a fresh chat when switching topics
  • If you can –> Combine Cursor with Ollama + local models

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
Business, JavaScript, webdev

Craft Exceptional Web Experiences as a Full-Stack Engineer

At EspressoLabs.com, we’re on a mission to redefine the future of IT/Security management through exceptional user experiences and cutting-edge technology.
We believe that enterprise software should not only be powerful and scalable but also intuitive, elegant, and a joy to use.

We’re building a platform that merges AI-intelligence with seamless design—and we’re looking for a Full-Stack Developer who shares our passion for creating meaningful, impactful technology.

Continue reading →
Standard
Design, webdev

Essential System Design Tips for Startups

You’re launching your first startup… Well, Congrats!

Whether it’s a SaaS invoicing tool, an e-commerce shop for handmade goods, or a new social app, you’ll quickly hit a truth: system design is your blueprint.

Done right, it makes your app boringly reliable. Done wrong, you’ll spend more time firefighting than building features.

This post is based on Sean Goedecke’s excellent piece on system design, reshaped with a founder’s lens: lean, practical, and ready for bootstrapped growth.

Continue reading →
Standard
Chrome, JavaScript

Effortlessly Compare Strava Activities with This New Tool

If you’re a cyclist, runner, or triathlete, chances are you’ve spent more time than you’d like clicking back and forth between Strava tabs to figure out where you gained or lost time on a ride. I’ve been there — juggling two activity pages, scrolling, mentally matching segments, and trying to keep my eyes from glazing over.

That’s exactly why I built the Strava Segment Comparator Extension.

It’s a lightweight, privacy-friendly tool that runs entirely in your browser, lets you quickly compare any two Strava activities, and shows segment-by-segment differences in both time and speed. Whether you’re racing a friend, analyzing your improvement, or just curious how different routes stack up, this extension saves you time and keeps your focus where it matters — the data.

You can also see all the TL;DR here.

Continue reading →
Standard
JavaScript, webdev

EspressoLabs Coding Challenge: Build a Real-Time Chat App

At EspressoLabs, we’re always on the lookout for talented engineers who can move fast, think clearly, and build scalable systems. Our home assignment is designed to evaluate just that — and we keep it focused and time-boxed.

“Talk is cheap. Show me the code.”
– Linus Torvalds

Continue reading →
Standard
JavaScript, webdev

The Future of Coding: LLMs as Collaborators

The rise of large language models (LLMs) has been one of the most transformative developments in software engineering in decades. Tools like GPT4.1, Gemini 2.5 Pro, Claude Opus 4, and various AI-powered code editors such as Cursor (or CoPilot) promise to change the way we build software.

But as these tools evolve and mature, the real question isn’t if we should use LLMs—it’s how.

There’s an emerging split in philosophy between two approaches: full automation through AI agents and IDE integrations, or human-led development using LLMs as intelligent partners.

Based on real-world experiences and a critical review of LLM-based coding tools, the most effective path today is clear:

LLMs are best used as powerful amplifiers of developer productivity—not as autonomous builders.

Let’s break down why.

Continue reading →
Standard