Blog
Writing
August 5, 2026
Is self-hosting an AI model actually cheaper than paying for an API?
I run a self-hosted AI model on a 2 GB VPS for this blog. Here is the real cost math on self-hosting vs a hosted API, where the break-even actually sits, and the costs the comparison usually leaves out.
July 30, 2026
Best low-cost AI video generator: what actually fits a $15-a-month budget
A practical look at low-cost AI video generators for short b-roll clips: real prices, what "unlimited" actually means in practice, and a comparison table for picking one without wasting a month on the wrong plan.
July 29, 2026
AI log, day 18: retrying a tool call retries a side effect, not just an HTTP request
Day eighteen of the AI log covers what happens when an agent times out waiting on a tool call and retries it: if the tool has a side effect, a retry after an ambiguous failure can double a charge, an email, or a database row instead of just resending some bytes.
July 28, 2026
Can AI replace motovlogging? What it takes over, and what it cannot
AI can already generate the road, the engine noise, the voice, and the edit. So can AI replace motovlogging? Here is what it genuinely takes over from motovloggers, the one thing it cannot fake, and why the real threat is not quality but volume.
July 23, 2026
AI image prompts that actually work (and the other prompts I use daily)
A tested prompt library, not a listicle: the exact structure behind AI image prompts that produce usable results on the first few tries, plus the code review, debugging, and writing prompts I reach for outside of images.
July 23, 2026
AI log, day 17: a tool schema is an API contract nothing enforces
Day seventeen of the AI log covers what happens when a tool definition changes shape: renaming a parameter or adding a required field does not throw a compile error, it just makes the model guess, and the failure looks like a wrong answer instead of a broken build.
July 22, 2026
Why 'it'll take a day' always turns into three
The gap between a one-day estimate and the three days it actually takes is not bad guessing. It is the estimate only ever pricing the part of the work you can already see.
July 22, 2026
AI log, day 16: the agent did not need a memory, it needed a source of truth
Day sixteen of the AI log finds a third shape of the memory question from days 14 and 15: some facts should never have been stored as memory at all, because a live system already owns them.
July 21, 2026
Distributed locks: the mutex that wasn't one
A Redis lock meant to guarantee one worker processes a billing job at a time still let two run at once, because a lock with only a TTL cannot tell an expired holder from one that is still working.
July 21, 2026
AI log, day 15: giving an agent long-term memory is harder than bolting on a database
Day fifteen of the AI log looks at memory that is supposed to outlive a single conversation, and why storing a fact once and retrieving it later is the easy ten percent of the problem, not the whole thing.
July 20, 2026
AI code review tools: what they actually catch, and what they miss
A year of running AI code review on real pull requests, and where it genuinely earns its spot in the workflow versus where it quietly misses the bugs that matter.
July 20, 2026
Working async across timezones when the team is one person
Freelancing from Nepal for clients scattered across timezones means most collaboration has no synchronous fallback, so a vague status message can cost someone a full working day. What actually makes async communication work: preempting the obvious follow-up question and being explicit about response latency instead of leaving it ambiguous.
July 20, 2026
The text file of things I don't understand yet
A running plain-text list of small confusions from the working day, a term used in a meeting, a config flag whose effect was assumed rather than verified, added to in the moment instead of resolved on the spot, then cleared in batches. Why separating noticing a gap from fixing it right away is what made the habit stick.
July 20, 2026
Deciding what belongs in the request and what belongs in a job queue
A report-generation endpoint ran synchronously and worked fine for small inputs, until larger ones made the client time out while the server kept working, and a client retry on that timeout ran the same expensive job twice at once. A slow synchronous endpoint is not just a latency problem, it breaks the request/response model's assumption that a timeout means nothing happened.
July 20, 2026
Testing in production sounds reckless until you realize you already do it
A canary rollout, a flag gated to internal users, watching error rates after a deploy: all of those are testing in production, and pretending staging catches everything is what actually causes surprises, since staging never sees real traffic shape or real concurrent load. The honest position is not "never test in production," it is "control the blast radius of the test you are already running."
July 20, 2026
The DNS TTL nobody lowered until it was too late
Migrating a domain to a new server, I updated the A record and watched a meaningful chunk of traffic keep hitting the decommissioned old server for most of a day, because the TTL had been left at its original default for years. A DNS TTL is a promise about how fast you can change your mind, made in advance, not at the moment you need it.
July 20, 2026
AI log, day 14: context windows are memory, and memory is not free
Day fourteen of the AI log treats a long-running agent's context window as its entire memory, with nothing else backing it, and walks through why the two practical fixes, summarizing older turns and retrieving only what's relevant, both trade one failure mode for another instead of solving the problem.
July 19, 2026
Burnout doesn't look like exhaustion, at first
The early warning sign of burnout was not tiredness, it was a specific flattening: work that used to feel like a win started producing no reaction at all on finishing it. Exhaustion is the symptom everyone watches for, and by the time it shows up, the earlier and more useful sign already got missed for weeks.
July 19, 2026
Backing up a database small enough to fit on a laptop, and still getting it wrong
The database was small enough that formalizing backups felt like overkill, so a cron job piped pg_dump to a file on the same VPS. A restore was never actually tried until real data got corrupted, months in, and the backup job had been silently failing for weeks. A backup you have not restored from is a theory, not a backup.
July 19, 2026
Trunk-based development when the team is just you
I kept the long-lived feature branch habit from team jobs after going solo, and it backfired every time: branches sat for a week, drifted from main, and merging back took longer than writing the feature did. Branch isolation protects people from each other, and with a team of one there is no one to protect against.
July 19, 2026
Request timeouts: the setting everyone copies from a tutorial
A 30-second timeout copied from a tutorial looked reasonable on its own, until an upstream gateway with a 10-second timeout gave up and retried the same call while it was still running, doubling load on an already-slow dependency. A timeout is a property of the whole call chain, not a number you pick in isolation.
July 19, 2026
The index that made the query slower, not faster
Adding an index sped up the one query it was meant for, and quietly slowed down everything else writing to that table, plus one unrelated query the planner started routing through it for the worse. Indexes are a trade you make on behalf of every writer, not a free gift to the query you were optimizing.
July 19, 2026
Graceful shutdown: handling SIGTERM instead of getting killed mid-request
Every deploy on our VPS killed a handful of in-flight requests because the process died the instant it received SIGTERM. What actually fixes it: trapping the signal, draining connections within a bounded grace period, and pulling the instance out of rotation slightly before the process starts shutting down.
July 19, 2026
AI log, day 13: guardrails are a UX problem, not just a safety one
Day thirteen of the AI log argues that a guardrail which blocks silently is indistinguishable, to the person on the other end of it, from the agent just being wrong or broken, and that the confirmation gate day nine and day eleven both argued for is a UX surface as much as it is a permission check.
July 18, 2026
Reading other people's code all day is an underrated skill
Most of an engineer's actual working day is reading code someone else wrote, not writing new code, yet nobody interviews for it or practices it on purpose. A habit that made unfamiliar codebases genuinely faster to understand, and why comprehension speed is trainable instead of just a side effect of tenure.
July 18, 2026
What most code review comments are actually arguing about
Most contentious code review threads are not disagreements about the code being wrong, they are a proxy fight over an unstated default like naming or where a helper function should live, and naming that default out loud ends the argument faster than re-arguing the diff.
July 18, 2026
Health checks that lie: liveness vs readiness
A single /health endpoint returned 200 as long as the process was running, used for both restart decisions and load-balancer routing. During a database outage every instance stayed alive and kept receiving traffic it could not serve, while nothing ever restarted, because "alive" was technically true.
July 18, 2026
Verifying webhooks: signatures, timestamps, and replay attacks
A webhook receiver checked a shared-secret header and called it verified, until it became clear that a captured, otherwise-legitimate request could be replayed at any later time. Why a signature without a timestamp only proves who sent something, not when.
July 18, 2026
Cursor pagination vs offset: why offset breaks under real writes
An API paginated with LIMIT/OFFSET worked perfectly in every test, then started showing users duplicate and missing rows in production as the table kept changing underneath each page fetch. Why offset pagination assumes a frozen dataset that no production table actually is.
July 18, 2026
Retries need backoff and jitter, or they become the outage
A downstream API blipped for four seconds, every client retried on the same fixed interval, and the synchronized retry wave kept it down for another six minutes. Why a retry policy without jitter is just a delayed, synchronized copy of the same load spike.
July 18, 2026
AI log, day 12: what changes when more than one model is involved
Day twelve of the AI log looks at what breaks once a second model enters the loop: an upstream hallucination becomes a downstream model's ground truth with no warning label, and every model-to-model hop multiplies cost, latency, and the same trust gap day nine already found no clean fix for.
July 17, 2026
AI log, day 11: evaluating an agent, not just its final answer
Day eleven of the AI log returns to evals now that chatbot, workflow, and agent have separate definitions. A single-call eval checks an answer. An agent produces a trajectory, a sequence of decisions that can go wrong at step three and still land on a plausible-looking answer at step seven, so the eval has to check the path, not just the destination.
July 17, 2026
N+1 queries: the bug that survives every code review
Why a loop that fires one database query per row reads perfectly fine on review, the admin dashboard that fell over because of it, and the query-count budget that actually catches this class of bug before it reaches production.
July 16, 2026
The "10x engineer" myth, examined from the inside
I've been called a 10x engineer a couple of times, on projects where I genuinely did ship faster than everyone else on the team. Looking honestly at what was actually different those times, it was never a 10x brain. It was context, fewer interruptions, and having already made the mistakes once before, and none of those things are a personality trait.
July 16, 2026
The "temporary" migration script that ran in production for three years
A one-off script written to backfill a column, meant to be deleted the same afternoon, ended up running on a cron job in production for three years, with nobody quite sure who owned it. Why "temporary" code so reliably outlives its intended lifespan, and the two habits that actually prevent it.
July 16, 2026
Environment variables are not secrets management
Putting a database password in a .env file feels like secrets management because it keeps the value out of the code, but env vars were designed to configure processes, not to protect credentials, and the gap between those two jobs is exactly where real leaks happen.
July 16, 2026
Circuit breakers: stopping one slow dependency from taking down everything
A downstream payment provider got slow, not down, just slow, and it nearly took the whole API with it through nothing but ordinary timeout and retry behavior. What a circuit breaker actually does, why retries alone make a slow dependency worse instead of better, and how to size the thresholds without guessing.
July 16, 2026
AI log, day 10: chatbot vs. agent vs. workflow, what genuinely separates the three
Day ten of the AI log pulls apart three words the current AI wave uses interchangeably: chatbot, agent, and workflow. Not a vibes-based distinction but a structural one, built on the model-call loop, tool use, and cost mechanics covered in the earlier entries, and what that structural line actually predicts about where each one breaks.
July 15, 2026
Eight years into an engineering career: what actually got easier, and what didn't
A look back at eight years of software engineering, from an HTML and CSS design intern to a senior engineer managing a team: which parts of the job genuinely got easier with time, which parts just changed shape, and why imposter syndrome never fully leaves, it just finds a new target.
July 15, 2026
Worker pools in Go: bounding concurrency without reaching for a library
A "go func()" per item works fine until the list is long enough to open a thousand goroutines at once. How bounded worker pools actually work in Go, the incident that taught me to stop trusting unbounded fan-out, and when a plain semaphore is enough versus when you actually need a pool.
July 15, 2026
Caching strategies: cache-aside, write-through, and write-behind, and when each one bites you
Cache-aside, write-through, and write-behind all solve "the database is slow" but fail in completely different ways. A walkthrough of each pattern, the specific bug each one is prone to in production, and how to pick between them instead of defaulting to whichever one the first tutorial you read happened to use.
July 15, 2026
AI log, day 09: prompt injection is what happens when data can talk
Day nine of the AI log covers prompt injection, the security failure specific to LLM-based systems: why data the model reads can override the instructions it was given, why it is a different bug than hallucination even though both share the same root cause, and why "just tell it not to listen to that" is not a real defense.
July 15, 2026
AI log, day 08: hallucination is a sampling problem, not a lying problem
Day eight of the AI log goes back to hallucination for the mechanical version day one only sketched: why next-token prediction has no "I don't know" state, why retrieval reduces but never eliminates it, and which fixes actually lower the rate versus which ones just make the wrong answer sound more confident.
July 14, 2026
AI log, day 07: a model call is a billed API call, not free compute
Day seven of the AI log looks at cost and latency through a backend engineer's cost-per-request instincts: tokens are the unit of both the bill and the wait, an agent loop multiplies both, and the context you re-send every turn makes a long loop cost more than it looks.
July 14, 2026
Why I Still Reach for Puppeteer in 2026
For automated data scraping that has to survive real-world, JavaScript-heavy websites, a headless browser still earns its overhead. Here is when and why.
July 14, 2026
Cron Jobs and Queues: The Work Nobody Demos
Background jobs never show up in a product demo, but they are usually what keeps the actual product from quietly falling apart. Notes from years of building them.
July 14, 2026
Headless WordPress, One Login for Everything
Integrating headless WordPress into a Laravel application, and why we ended up writing a custom SSO plugin instead of reaching for an off-the-shelf one.
July 14, 2026
AI log, day 06: an agent is a loop, not a personality
Day six of the AI log strips the buzzword off "agent": underneath, it is a plain loop of model, tool call, result, repeat, with the model choosing which tool to call, and most of the engineering is in the boring plumbing around that loop rather than the model itself.
July 14, 2026
What Nobody Tells You About Becoming a Team Lead as an Engineer
The jump from writing code to being responsible for a team is not a promotion in the way most engineers expect. Here is what actually changed for me.
July 13, 2026
Everyone is "quiet quitting" again, except this time it has a new name
The trend of doing exactly what your job description says and nothing more keeps coming back under a new label. A look at why it resurfaces, what actually changed this time, and what it gets right that the discourse around it usually misses.
July 13, 2026
AI log, day 05: evals, or how you tell better from felt-better
Day five of the AI log is about evals: the difference between a prompt change that actually made things better and one that just felt better on the single example you tried by hand, and the smallest honest setup for telling them apart.
July 13, 2026
World Cup semifinal preview: Norway have one game left to shock everyone
Norway face their first ever World Cup semifinal this week after beating England on penalties. A look at who they play, what has actually worked for them, and why the whole run could end on the smallest detail.
July 12, 2026
I tried "monk mode" for 30 days. Here is what actually changed
Everyone online is doing monk mode right now, no phone, no socializing, just work and discipline. I tried it for a month as a working developer. Here is what stuck, what did not, and what I would tell someone about to start.
July 12, 2026
Norway beat England, and I am typing this on two hours of sleep
Norway beat England on penalties in the World Cup 2026 quarterfinal, sending Haaland and a country of five million to their first ever semifinal. A 2am reaction, still half awake.
July 11, 2026
Norway vs England, World Cup 2026: why we are staying up at 2:45am for Haaland
Norway play England in the World Cup 2026 quarterfinal tonight, kicking off at 2:45am in Nepal. Here is why Haaland has an entire country in Nepal setting alarms for a team most of us could not find on a map two weeks ago.
July 11, 2026
Pritam and Pedro review: Rajkumar Hirani's OTT debut is a fun weekend watch
A full review of Pritam and Pedro, Rajkumar Hirani's Goa-set cybercrime buddy-cop series on JioHotstar starring Arshad Warsi and debutant Vir Hirani. Plot, cast, verdict, and whether it is worth your weekend.
July 11, 2026
AI log, day 04: fine-tuning is the last resort, not the first move
Day four of the AI log works through fine-tuning versus RAG versus just writing a better prompt, and argues the popular order is backwards: reach for a structured prompt first, RAG second, and fine-tuning only once both have genuinely run out of road.
July 10, 2026
Message queues without the buzzwords: when a plain table beats Kafka
Before reaching for Kafka or RabbitMQ, a job table on the Postgres you already run, with SELECT ... FOR UPDATE SKIP LOCKED, handles most background work fine and buys time to actually learn if you need more.
July 10, 2026
AI log, day 03: a prompt is an API contract, not a magic spell
Day three of the AI log stops treating prompting as phrasing tricks and starts treating it as an interface: system prompt as config, few-shot examples as test cases, structured output as a return type, and why sharing one text channel for instructions and data is a security problem, not just a quality one.
July 9, 2026
GPT-5.6, Grok 4.5, and the day every AI lab shipped at once: the real lesson for engineers
OpenAI shipped GPT-5.6, xAI (now SpaceXAI) shipped Grok 4.5, and Microsoft quietly started swapping its own models in for OpenAI and Anthropic in production. Here's why the model that wins this week matters less than whether your code can survive next week's winner.
July 9, 2026
AI log, day 02: temperature and sampling, what turning the dial actually changes
Day two of the AI log picks up where generation left off: the temperature, top-p, and top-k knobs that decide which token gets picked next, what they actually do to the math, and why the wrong setting silently made a project less reliable.
July 8, 2026
Java: the language I learned first and never got to use
Java was my first real programming language, taught to me at a small tuition centre called Stosh Java, and I still have never used it in a professional job. Here is why I still keep an eye on it.
July 8, 2026
AI log, day 01: tokens, embeddings, and how a model actually generates text
Starting a day-by-day log of learning AI from the ground up. Day one covers the four ideas everything else sits on: tokens, embeddings, context windows, and how generation actually happens, revisited against a RAG pipeline I already built.
July 8, 2026
What you actually get when you hire a freelance developer from Nepal
Two years of remote work for a US company taught me what actually matters when a foreign client hires a developer from Nepal: real overlap in working hours, honest communication, and rates that reflect cost of living, not corners cut.
July 7, 2026
Cristiano Ronaldo, out of the World Cup, and out of time
Portugal lost to Spain today and Ronaldo is out of World Cup 2026, probably for good. A personal note on a childhood favorite and the last international game he has left.
July 6, 2026
Split delivery: hosting one mailbox on a different provider
How to make a single address on your Google Workspace domain deliver to a different mail provider, why the obvious approaches fail, and the one Gmail setting that actually makes it work.
July 6, 2026
Is AWS actually cheaper than other hosting providers?
Brief answer: usually not for simple hosting, sometimes yes for specific workloads. A quick comparison of current public pricing and where the real bill tends to grow.
July 6, 2026
Beginners can still earn in software after AI
If AI has you wondering whether there is still room to start, there is. Early income in software comes from solving small real problems, and that need has not gone away.
July 6, 2026
How lifestyle inflation quietly eats every raise
A bigger paycheck helps, but if your fixed costs rise alongside it, the raise disappears into a more expensive version of the same life.
July 5, 2026
Was Elon Musk really right about AI?
Sorting the specific AI predictions Musk has made over the past decade into what actually happened, what did not, and what that says about predicting AI from outside the room where it gets built.
July 5, 2026
What AI actually does to jobs that never touch a keyboard
AI is not replacing the electrician, the cook, or the warehouse picker. It is changing the scheduling, dispatch, and pricing layer around their jobs, and that is where the real pressure lands.
July 5, 2026
AI took the busywork. What is left is the actual engineering.
Handing the bottom-level work to AI does not shrink the engineering job, it exposes who was actually doing it. Notes from managing a team through that shift.
July 5, 2026
Database migrations that don't wake you up at 2am
A phased approach to writing production database migrations, so adding a column or backfilling data does not lock the table or page you at night.
July 5, 2026
Context cancellation in Go: getting it right
How context cancellation actually propagates through a Go call chain, and the mistakes that quietly keep goroutines and downstream calls running past the point they should have stopped.
July 5, 2026
Structured logging: what to log and what to skip
A practical guide to structured logging in production services: which fields earn their place, which ones are noise, and how to correlate logs across services with a request id.
July 4, 2026
From QBasic to production systems: how I got into software engineering
The path from a QBasic class in a school computer lab in Hetauda to writing backend systems in Tokyo, and the moments in between that decided it for me.
July 4, 2026
CI/CD for a solo dev: what's worth automating and what isn't
A practical look at how much CI/CD a solo developer actually needs, with a minimal GitHub Actions example and a case for deploying straight off main.
July 4, 2026
Connecting the dots: how software engineers actually make money
A salary is one node in a bigger graph. Freelancing, writing, and side projects are not separate lanes, they are the same skill pointed in different directions.
July 4, 2026
Is money actually needed for a better life?
Money fixed real, specific problems early in my career. Past a certain point it stopped fixing anything new, and I kept chasing more of it out of habit.
July 4, 2026
Postmortem format: what makes a debugging writeup actually useful
Most postmortems get written, filed, and never opened again. Here is what separates the ones people actually reread from the ones that just check a box.
July 3, 2026
What I learned building a RAG pipeline in Go
A weekend project to search internal docs with plain-language questions taught me that chunking and data hygiene matter more than which model you pick.
June 26, 2026
What actually changed after six months of writing Go
A follow-up to the original PHP-to-Go post: what held up, what surprised me, and what I would tell myself starting over.
June 19, 2026
Rate limiting a public API: token bucket vs sliding window
Two common rate-limiting algorithms, what they actually do differently, and which one fits a bursty public API.
June 12, 2026
Zero-downtime deploys on a single VPS
No Kubernetes, no load balancer, just nginx and a build step. Here is what it actually takes to avoid downtime on deploy.
June 5, 2026
Feature flags without a vendor: a minimal in-house approach
You don't need LaunchDarkly to ship behind a flag. A config table and a small helper function gets you most of the way there.
May 29, 2026
Writing idempotent API endpoints (and why it matters for retries)
Clients retry on timeouts whether you plan for it or not. Idempotency keys are how you stop that from double-charging someone.
May 22, 2026
What actually breaks when you scale a Postgres-backed API
Connection pool exhaustion, missing indexes, and N+1 queries: the three things that actually bite you first.
May 15, 2026
API versioning strategies that don't turn into a mess
URL versioning, header versioning, or none at all: what actually holds up once an API has real external consumers.
May 8, 2026
Structuring a Go project past the "just main.go" stage
A single main.go works fine until it doesn't. Here's how I organize Go services once they outgrow one file.
May 1, 2026
What actually changes when you move from PHP to Go
The parts of the PHP and Laravel mental model that transfer to Go, and the parts that do not.
April 24, 2026
AWS Lambda vs GCP Cloud Run: picking the right serverless model
Notes from running the same workload on both, and the tradeoffs that actually mattered once real traffic hit.
April 17, 2026
Debugging a goroutine leak in production
A slow memory climb in a Go service turned out to be goroutines parked on a channel that never closed. Here is how we tracked it down.
April 10, 2026
Hello, World
Why I am starting this blog, and what I plan to write about: backend systems, cloud architecture, and the stuff that breaks in production.