Notes from the lab.

Published journal entries covering engineering decisions, tradeoffs, and field notes.

• Starting 2026: New Year, Same Hustle

  New year, same mission. Here's my approach for the months ahead.

• Year in Review: 2025

  What a year. Job hunting, building, writing, and growing through it all.

• Node.js Streams: A Practical Guide

  Streams handle large data efficiently. Here's how to use them without the headache.

• Lessons from 70 Blog Posts

  I've written 70 posts this year. Here's what I learned about consistent content creation.

• React Server Components: A Primer

  Server Components change how we think about React. Here's what you need to know.

• API Rate Limiting Implementation

  Protect your API from abuse. Here's how to implement rate limiting in Node.js.

• Webpack vs Vite in 2025

  Vite has gained massive popularity. When should you use it vs Webpack?

• Understanding JWT Authentication

  JWTs are everywhere in modern web auth. Here's how they work and how to use them properly.

• Redux in 2025: Is It Still Worth Learning?

  With so many state management options now, is Redux still relevant? Let's talk about when it makes sense and when it doesn't.

• Building a Simple Chatbot (No AI Required) - Part 2

  Time to add the brains! Let's write the JavaScript that makes our chatbot actually respond to users.

• The Year-End Job Hunt Push

  The market supposedly slows down in December. But does it? My strategy for the next few weeks.

• SQL Joins Visualized

  Joins combine data from multiple tables. Here's a visual guide to the different types.

• VSCode Snippets: Type Less, Code More

  Custom snippets save keystrokes and enforce patterns. Here's how to make them.

• HTTP Caching Explained

  Proper caching makes sites fast. Here's how HTTP caching works and how to use it.

• Building a Simple Chatbot (No AI Required) - Part 1

  Ever wanted to build a chatbot but don't want to mess with AI APIs? Let me show you how to build one with just HTML, CSS, and JavaScript.

• The Job Hunt is Brutal Right Now

  Been on the job market for a bit now. Let me tell you, it's not great out there. Here's what I'm seeing.

• My VS Code Setup for 2025

  I spend way too much time tweaking my editor. Here's what I've landed on for my daily driver setup.

• Getting Started with Next.js 15: What's New

  Next.js 15 dropped and there's some genuinely cool stuff in here. Let me walk you through the highlights.

• Building a Chatbot from Scratch: Part 6 - Deployment

  The final chapter: deploying our chatbot to the world with Docker and a VPS.

• Coder Life Community: One Year Later

  The Coder Life Discord has been running for a year. Here's what I've learned about building developer communities.

• React Context: When to Use It

  Context is powerful but often misused. Here's when it makes sense and when it doesn't.

• When Technical Interviews Go Wrong

  More interview stories from the trenches. The good, the absurd, and the lessons learned.

• Regular Expressions: The Essentials

  Regex looks scary but it's incredibly useful. Here are the patterns you'll actually use.

• Feature Flags: Ship Faster, Safer

  Separate deployment from release. Feature flags let you ship code without exposing features.

• Building a Chatbot from Scratch: Part 5 - Styling

  Our chatbot works. Now let's make it look professional with modern CSS.

• Prettier: Solve Formatting Arguments Forever

  Stop arguing about tabs vs spaces. Let Prettier decide and move on.

• Deploying Node.js Apps with PM2

  PM2 keeps your Node apps running. Process management, clustering, and monitoring.

• Halfway Through the Year: Reflections

  The job search continues. But a lot has happened. Time for reflection.

• Testing React Components: A Practical Guide

  Testing doesn't have to be painful. Here's a practical approach that actually helps.

• JavaScript Dates Are Weird

  The Date object is confusing. Here are the gotchas and how to handle them.

• Why I Still Love React in 2025

  React has been around for over a decade now, and honestly? I'm still a fan. Here's why I think it's still the go-to for building UIs.

• REST API Versioning Strategies

  You need to change your API but can't break existing clients. Here are your options.

• React Error Boundaries in 2025

  Graceful error handling in React. What error boundaries are, how to use them, and patterns that work.

• Job Hunting: The Networking Game

  I hate networking. But ignoring it was a mistake. Here's what I learned.

• When to Use useCallback and useMemo

  These hooks are for optimization, not decoration. Here's when they actually help.

• My Terminal Setup in 2025

  A fast, pretty terminal makes development more enjoyable. Here's my current setup.

• Technical Writing for Developers

  Writing docs, READMEs, and technical posts is a skill. Here's how to get better at it.

• Building a Chatbot from Scratch: Part 4 - Adding Intelligence

  Our chatbot responds to messages. Now let's make it actually useful with pattern matching and response logic.

• Async/Await: Common Mistakes

  Async/await makes promises easier, but there are still pitfalls. Here are the mistakes I see most often.

• Mobile Debugging: slapjs-mobile-debugger

  Debugging in mobile browsers is painful. I built a tool to make it less so.

• Web Accessibility: The Basics

  Accessibility matters. Here are the fundamentals every web developer should know.

• The Side Project Graveyard

  I have dozens of unfinished projects. Some guilt, some wisdom, and why that's actually okay.

• React Forms: Controlled vs Uncontrolled

  When should you control form state? When should you let the DOM handle it? Let's break it down.

• What I Look for in Code Reviews

  Code review isn't about gatekeeping. It's about making code better together. Here's what I focus on.

• Environment Variables in Node.js

  Managing configuration across development and production. Here's how I handle env vars.

• Debugging Tips That Actually Help

  Debugging is a skill. Here are techniques that help me find and fix bugs faster.

• Blankpage: Real-Time Collaborative Code Review

  I built a real-time collaborative editor for code review. Here's the story and tech behind it.

• Why I Prefer Postgres Over MySQL

  For most of my projects, I reach for PostgreSQL. Here's why it's become my default database.

• Git Commands I Use Every Day

  I've been using Git for over a decade. Here are the commands that actually matter for daily work.

• Six Months of Job Hunting: A Retrospective

  I've been on the market for half a year now. Here's what I've learned, what worked, and what didn't.

• Next.js App Router: The Mental Model

  App Router confused me at first. Here's the mental model that made it click.

• Reading Code Is a Skill

  We spend way more time reading code than writing it. Here's how to get better at it.

• API Error Handling: Do It Right

  Most APIs have terrible error handling. Here's how to build error responses that actually help developers.

• Building a Simple Chatbot - Part 3: Adding Context

  Our chatbot can respond to messages, but it doesn't remember anything. Let's add conversation context.

• The Tools That Actually Make Me Productive

  After 15+ years of collecting tools, here are the ones I actually use daily.

• Why I Still Write Vanilla CSS (Sometimes)

  Tailwind, CSS-in-JS, SASS... sometimes plain CSS is still the right choice.

• Building My Personal Infrastructure with Docker

  I run a bunch of services on my VPS. Here's how Docker Compose keeps it all manageable.

• Chrome Extensions: My Dev Toolkit

  Here are the browser extensions that make my development workflow smoother.

• React Hooks Deep Dive: useCallback and useMemo

  These two hooks confuse a lot of people. Let's break down when you actually need them (and when you don't).

• React Component Patterns I Use Every Day

  After years of React, these are the patterns that have stood the test of time. Simple, effective, and maintainable.

• When AI Screens Your Resume

  Your job application probably never reaches a human. Here's how to write for the robots while staying authentic.

• TextGuard: Building a Spam Detection App

  I built a spam detector without using any AI APIs. Here's how heuristics and basic probability can go a long way.

• Express.js Deep Dive: Middleware Patterns

  Middleware is the backbone of Express. Let's look at patterns that make your APIs more robust and maintainable.

• Docker for JavaScript Developers: A Practical Guide

  Docker can seem intimidating at first. Let me break it down in terms that make sense for web developers.

• The Technical Interview Is Broken

  Whiteboard algorithms, LeetCode grinding, system design for a CRUD app... the way we interview developers needs to change.

• TypeScript Tips: Utility Types You Should Know

  TypeScript's built-in utility types can save you tons of boilerplate. Here are the ones I use constantly.

• Introducing Coder Life: A Community for Developers

  I started a Discord community for developers. Here's what it's about and why you might want to join.

• GraphQL vs REST: When to Use Which

  The GraphQL hype has died down. Let's have a real conversation about when each makes sense.

• ZipDrop: Why I Built a Browser-Based File Compressor

  Sometimes you build things because you need them. ZipDrop is one of those projects.

• Express.js Basics: Setting Up Your First API

  New to backend development? Let's build a simple REST API with Express.js from scratch.

• Interview Horror Stories: The 8-Hour Take-Home

  I was told it would take 4 hours. It took 8. And then they ghosted me. Let's talk about take-home assignments.

• Building AI Features with OpenAI API

  Add AI capabilities to your apps. A practical guide to the OpenAI API.

• Validate API Responses at the Boundary in TypeScript

  Treat incoming JSON as unknown, then check its shape before handing it to the rest of your application.

• Copy the array before you sort it

  JavaScript’s sort() changes its input. Keep display ordering separate from shared data with a copied array and an explicit comparator.

• When to return after sending an Express response

  Sending a response finishes the HTTP exchange. Calling next() is a separate decision—and usually the wrong one afterward.

• Keep repeated query parameters when editing a URL

  URLSearchParams supports repeated keys, but set() and Object.fromEntries() can quietly discard them. Use getAll() and append() when a filter accepts multiple values.