Writing

The Blog

Thoughts on Python engineering, data architecture, enterprise systems, and 25+ years of lessons learned the hard way.

March 25, 2026

Is Claude Code Worth It If You Already Use ChatGPT and GitHub Copilot?

A third AI subscription is a hard sell. Here's an honest cost-benefit breakdown of where Claude Code earns its place — and where it's redundant.

AIClaude CodeDeveloper ToolsGitHub Copilot

Read Article

Apr 5, 2026

3 min read

AI Can Write Code — But It Can't Replace Thinking: Why Learning Programming Still Matters

GitHub Copilot generates the snippet. ChatGPT explains the error. But neither can decide if the architecture is wrong. Foundational programming knowledge is more valuable now, not less.

AISoftware EngineeringProgramming

Apr 12, 2026

3 min read

Gratitude, Growth, and the Weight of a Long Goodbye

After 26 years with one company, a LinkedIn farewell post becomes a meditation on how long careers shape identity — and why every role, challenge, and colleague leaves a mark.

The Blog

Is Claude Code Worth It If You Already Use ChatGPT and GitHub Copilot?

AI Can Write Code — But It Can't Replace Thinking: Why Learning Programming Still Matters

Gratitude, Growth, and the Weight of a Long Goodbye

Talking to the Machine: How to Survive — and Win — AI-Powered Job Interviews

From Procedures to Intelligence: A Developer's Shift Across Paradigms

Stop Burning Tokens: A Developer's Guide to Smarter AI Usage

Async Tasks in Django with Celery + Redis

Stop Using Django REST Framework for Internal APIs

Should You Be Able to Code Without AI? The Question Splitting the Dev Community

AI Hallucination: What It Is, How to Mitigate It, and How to Detect It

The Bottleneck Didn't Disappear. It Moved.

Django + DRF and Your Frontend: How the Pieces Actually Connect

Understanding IP Addresses

Django + GraphQL: What Actually Happens When You Wire Them Together

The OSI Model, Explained for Developers

10 Backend Concepts You Better Know Before Your Next Interview

The TCP/IP Model: A Developer's Refresher

DSA Interview Patterns, Part 1: Arrays, Strings, Sets, and Big O

DSA Interview Patterns, Part 2: Hash Maps

How DNS Actually Works

DSA Interview Patterns, Part 3: Two Pointers

DSA Interview Patterns, Part 4: Sliding Window

DSA Interview Patterns, Part 5: Binary Search

What Is a CDN?

DSA Interview Patterns, Part 6: BFS and DFS

DSA Interview Patterns, Part 7: Backtracking and Heaps

Behavioral or Technical? At the Senior Level, It's Not Even Close

Availability: The Metric Everyone Quotes and Almost Nobody Calculates Right

Behavioral Interviews for Software Engineers: An Introduction

Scalability: Why 'Just Add More Servers' Is Both Right and Incomplete

Caching: The Highest-Leverage Trick in System Design

Proxies: The Server in the Middle

Load Balancers: The Traffic Cop of Every System That Doesn't Fall Over

CAP Theorem: Why You Can't Have It All (And That's Okay)

PACELC: The Trade-off CAP Theorem Never Told You About

DBMS Fundamentals: The Layer Everyone Uses and No One Reads the Manual For

SQL vs NoSQL: Choosing the Right Database for Your Project

Database Replication: The Backup That's Also Your Bottleneck

Database Indexing: The Difference Between a 2ms Query and a 20-Second One

Database Normalization: The Complete Guide for Developers

Database Sharding: A Practical Guide to Scaling Beyond a Single Machine

N-Tier Architecture: Why Your App Shouldn't Be One Giant Blob

Monolith vs. Microservices: Choosing the Right Architecture

Message Brokers: The Middleman Your Services Actually Need

APIs Explained: How Software Talks to Software

REST, GraphQL, and gRPC: Three Ways to Ask for Data

WebSockets, Long Polling, and Server-Sent Events

Service Mesh: Who's Watching Your Microservices Talk to Each Other?

API Gateway: The Front Door to Your Backend

Rate Limiting: How Systems Protect Themselves From Their Own Popularity

Single Sign-On: One Login, Many Doors

OAuth: Letting Apps Act on Your Behalf Without Handing Over Your Password

Symmetric and Asymmetric Encryption

Consistent Hashing

Concurrency Control and Locks: Keeping Shared State Sane