DEV Community: Anup Karanjkar

Freelancer Tax Guide India ITR Filing, GST & Tax

Anup Karanjkar — Fri, 21 Aug 2026 13:15:08 +0000

Freelancer Tax Guide India ITR Filing, GST & Tax — this is a comprehensive guide covering everything you need to know.

What Is undefined?

[Explain the core concept in 2-3 paragraphs. Include practical context.]

How to Use undefined

[Step-by-step guide with examples. Include code snippets if relevant.]

Key Features and Benefits

[List 5-7 features with brief explanations.]

Common Mistakes to Avoid

[3-4 practical pitfalls and how to avoid them.]

Start with our free tool, then explore the comprehensive templates in the WOWHOW product catalog.

Originally published at wowhow.cloud

Freelancer Accounting in India: GST, ITR & Bookkeeping

Anup Karanjkar — Tue, 18 Aug 2026 13:15:05 +0000

Freelancer Accounting in India: GST, ITR & Bookkeeping — this is a comprehensive guide covering everything you need to know.

What Is undefined?

[Explain the core concept in 2-3 paragraphs. Include practical context.]

How to Use undefined

[Step-by-step guide with examples. Include code snippets if relevant.]

Key Features and Benefits

[List 5-7 features with brief explanations.]

Common Mistakes to Avoid

[3-4 practical pitfalls and how to avoid them.]

Start with our free tool, then explore the comprehensive templates in the WOWHOW product catalog.

Originally published at wowhow.cloud

Gauntlet Loop Reality Check — Costs Nobody Quotes (2026)

Anup Karanjkar — Sat, 15 Aug 2026 17:29:34 +0000

Blind reviewers scored "Claude of Duty" — the game that made the Gauntlet Loop famous — between 3.6 and 5.05 out of 10 against real Call of Duty footage. Every single reviewer correctly identified which game was the real one.[1] That number never appears in the viral threads. The 3.8M views did.

Here's the thing: the Gauntlet Loop is still the most useful prompting pattern to come out of 2026. Both statements are true at once, and if you only hear one of them you either dismiss a genuinely strong technique or you burn hundreds of dollars finding out what the hype left out. We did the full research pass — the original posts, the repo, the critiques, the cost reports — so you don't have to.

What the Gauntlet Loop actually is

In July 2026, Matt Shumer gave Claude Code a single short prompt and let it run unattended for hours. The result was a browser FPS — roughly 55,000 lines of Three.js, with every texture, mesh, animation, and sound generated procedurally at load time. No art files at all. The repo hit 1,547 stars in three days.[2] Decrypt ran it under the headline "The dumbest-looking AI prompt just beat months of careful game-design prompt engineering."[3]

This is the entire prompt, verbatim, from the public repo:

I want you to build a first-person shooter at the level of the most recent
Call of Duty games. It should be utterly perfect, visually beautiful, with
every single thing done at AAA quality—from textures to physics to anything
you could think of.

Fan out sub-agents and have sub-agents tackle each one individually so that
the game is utterly perfect. You should /loop on each item and have a
separate sub-agent check it visually to ensure it looks triple A. That
separate sub-agent should be a really harsh critic, and if it doesn't look
triple A, it should keep going.

Don't stop until each sub-agent is utterly wowed with the quality when
compared with the actual Call of Duty game. It should literally compare them
side by side blind and say which one looks better. Do this in ThreeJS.
/loop until it's utterly perfect. Fan out sub-agents and ultracode.

Strip the bravado and there are four load-bearing ideas in those three paragraphs:

1. A concrete bar, not adjectives. The agent doesn't chase "high quality" — it compares its output side by side against actual Call of Duty. A critic can argue with an adjective. It can't argue with a screenshot.

2. The agent splits the work. Not the human. The lead agent breaks the goal into the smallest pieces that can be improved and judged separately — the gun, the trees, the lighting, the movement.

3. Builder and critic are different agents. The builder has seen every decision it made and will defend all of them. A fresh-context critic that sees only the goal, the bar, and the real artifact gives an independent judgment. This mirrors what we found on our own stack — our highest-leverage agent is an adversarial verifier whose only job is to break changes, a lesson we wrote up in our CLAUDE.md production rules.

4. No fixed round count. The loop runs until the output wins the blind comparison or a human stops it.

That's the whole method. Now the part the threads skip.

The evidence nobody quotes

Pieter Levels — one of the most credible solo builders in public — posted his experience running Gauntlet Loops. It's worth quoting because almost nobody sharing the technique does:

"Every time I do a Gauntlet Loop I end up with a total mess and chaos of unperformant code and too many things happening and nothing works properly. And I burn $900. I have to remove 95% of what it made and go back to what I had."[4]

He's not alone on cost. Developer reports collected by Stork.AI put a Gauntlet-built F1 game at roughly $1,200 in tokens and a GTA-style attempt at $1,700.[5] The community packaging of the technique states the operating model plainly: "You are the brake. The loop will not finish on its own."

The failure modes are just as documented as the wins. The most substantive technical critique, from rise.sk's hands-on runs, found three that matter:[6]

Critic collapse. The single most common failure. Without a strong real reference, the blind critic slowly starts agreeing with the builder — inverting comparisons and approving everything. The loop keeps running. Nothing improves.

Parallel fan-out breaks coupled systems. When rise.sk let parallel agents work on interdependent rendering subsystems — tonemapping, sky, indirect lighting — they broke each other's assumptions and produced 66 defects. Switching the coupled systems to sequential work cut that to 26. Same method, 2.5x difference, purely from respecting coupling.

Critics grading summaries. Feed the critic the builder's description of the work instead of the actual rendered output, and it reviews the explanation — which is always flattering — not the artifact.

And the original demo itself? The project's own evaluation admits the final game never matched its Call of Duty reference — that 3.6–5.05/10 blind score above. Enterprise DNA's advice after reviewing the reception: discount one-shot demos by at least 50% when setting internal expectations.[1]

Why the method survives its own hype

Strip away the "AI built AAA" framing and what remains is a disciplined implementation of two patterns Anthropic itself documents for agent systems: orchestrator-workers for decomposition, and evaluator-optimizer for the improvement loop. The Gauntlet Loop's real contribution is operational — it makes the evaluator a separate, fresh-context agent judging real artifacts against a real reference, blind. That combination kills the failure mode where a model grades its own homework and always passes.

The reception splits exactly along whether people used those pieces. The wins — the landing-page case study where the critic flagged overlapping text overlays and vague copy through multiple blind rounds, the dozens of derivative games — all kept a hard reference bar. The disasters ran unbounded loops on coupled codebases with no cap and no budget.

One gap per round matters more than it looks. "Make the game better" is unattackable. "Make this one tree hold up against this tree in the reference screenshot" is a problem an agent can actually close. The single-biggest-gap rule is what turns a vague quality chase into a sequence of small, winnable fights.

The braked version that works

After running this research, we adapted the method for our own product work with four changes. Every one of them exists because of a documented failure above.

Hard round cap. Default 3 rounds per piece. When a piece hits the cap, the agent stops and reports the remaining gap honestly instead of burning more tokens. Raising the cap is a deliberate decision, not a default. This is the direct answer to the $900 problem.

Coupled pieces run sequentially. Anything that shares files or assumptions never fans out to parallel builders. That's the 66→26 lesson, and we'd already paid for it independently — parallel write agents on one codebase lose edits while reporting success.

Critics see artifacts only. Rendered screenshots, running code, actual test output. Never the builder's summary. If the critic can't inspect it, it can't judge it.

A real bar or no run. If there's no concrete reference — a competitor product, a screenshot set, a test suite — finding one becomes the first task. A critic without a bar collapses.

Here's the critic prompt we use for manual runs. Try it on your current project right now:

You are a harsh, independent critic. Here is a goal, a quality bar, and an
artifact. You have not seen how the artifact was made. Compare the artifact
side by side with the bar, blind. State which one wins. Then name the SINGLE
biggest remaining gap — one item only, the one that matters most. Do not
soften the verdict.

We packaged the whole thing — bar block, builder/critic split, blind A/B rule, round-cap brake, live progress page — into a free Gauntlet Loop Prompt Generator. It's template-based and fully client-side: no AI calls, no daily limit, and the template logic is shown openly on the page. If you want the deeper agent-workflow context first, our Claude Code cheat sheet covers the harness commands the loop relies on.

Should you run one?

Based on our analysis of every documented run we could find: yes, for the right jobs, with brakes on. The loop earns its cost when the output has a real competitor to beat — a landing page against the best site in its category, an article against the top-ranking result, a game against reference footage. It wastes money as a first-draft engine for routine work, and it actively damages coupled codebases when run in parallel.

If you're building agent workflows seriously, the prompts are the cheap part — battle-tested system prompts and guardrails are where the time goes. Our Claude Code Production Pack and the Agent Prompt Vault ship the configurations we actually run, including the adversarial verifier patterns this article describes.

Generate a braked Gauntlet prompt with the free generator, run it on something small, and watch the first loop finish before you scale. Every product mentioned is available at wowhow.cloud — pay once, ship forever.

Sources

7. How to Run a Gauntlet Loop — Matt Shumer, somethingbig.ai (Jul 2026)

Originally published at wowhow.cloud

Claude Code Cheat Sheet (2026) — Commands & Shortcuts

Anup Karanjkar — Sat, 08 Aug 2026 05:17:52 +0000

The ten commands below cover about 90% of a Claude Code session: /clear to reset context, /compact to summarize it, /context to see what is eating it, /model to switch models, /rewind to undo code and conversation, Shift+Tab to cycle permission modes, Esc to interrupt, Esc Esc to rewind, @ to attach a file, and ! to run a shell command inline. Everything else in this cheat sheet is the long tail you reach for less often but want on hand.

This is current for 2026 (Claude Code v2.1.x) and sourced from the official command reference, CLI reference, and interactive-mode docs. Availability varies by platform, plan, and version — check /help in your own install for the authoritative list.

Slash commands — the daily drivers

Type / at the start of a message to filter these. The ones you will actually wear out:

Command	What it does

| `/clear` (aliases `/new`, `/reset`) | Start a fresh conversation with empty context |

| `/compact [instructions]` | Summarize the conversation to free up context without losing the thread |

| `/context [all]` | Visualize current context usage as a colored grid — find what is bloating it |

| `/model [model]` | Switch model mid-session |

| `/rewind` | Roll code *and* conversation back to a checkpoint |

| `/plan` | Switch into plan mode before a large change |

| `/effort [level]` | Set model effort: low, medium, high, xhigh, max, ultracode |

| `/usage` (alias `/cost`) | Show token usage and cost for the session |

| `/resume [id]` | Return to an earlier conversation or session |

| `/config` (alias `/settings`) | Open settings — theme, model, preferences |

| `/memory` | Edit CLAUDE.md memory files and manage auto-memory |

| `/init` | Generate a CLAUDE.md guide for the current project |

Slash commands — review, workflow, and power tools

Command	What it does

| `/code-review [level] [--fix] [pr# | branch | path]` (alias `/review`) | Review a diff or PR for correctness bugs and cleanup |

| `/security-review` | Check the diff for security vulnerabilities |

| `/pr-comments [--fix]` | Post review findings as inline GitHub PR comments |

| `/verify` | Verify that code changes actually work |

| `/simplify` | Remove duplication and complexity from changed code |

| `/agents` | Manage subagent configurations |

| `/subtask [prompt]` | Hand a side task to a subagent; its result returns to your conversation |

| `/background [prompt]` / `/fork [prompt]` | Detach or copy the session to run as a background agent |

| `/loop [interval] [prompt]` | Run a prompt repeatedly while the session stays open |

| `/goal [condition]` | Set a goal — Claude keeps working until the condition is met |

| `/batch ` | Orchestrate large-scale changes across a codebase in parallel |

| `/hooks` | View hook configurations for tool events |

| `/permissions` | Set approval rules for file and command execution |

| `/mcp` | Manage MCP server connections and OAuth |

| `/diff` | Open an interactive diff of uncommitted changes |

| `/export [file]` / `/copy [N]` | Export the conversation as text / copy the last response |

| `/doctor` | Run a setup checkup that diagnoses and can fix issues |

| `/vim` | Open the response in your `$EDITOR` |

One structural change worth knowing: custom slash commands are now skills. A file at .claude/commands/deploy.md and a skill at .claude/skills/deploy/SKILL.md both create /deploy. Existing .claude/commands/ files keep working; skills add a supporting-file directory and frontmatter to control whether you or Claude invokes them.

CLI commands

What you run in the terminal before the session starts:

Command	What it does

| claude | Start an interactive session |

| claude "query" | Start interactive with an initial prompt |

| claude -p "query" | Print mode — query via SDK, then exit (great for scripts and pipes) |

| cat file | claude -p "query" | Pipe content in and process it headless |

| claude -c | Continue the most recent conversation in this directory |

| claude -r "" "query" | Resume a session by ID or name |

| claude mcp | Configure MCP servers |

| claude agents | Open the agent view to monitor and dispatch parallel background sessions |

| claude doctor | Print installation and settings diagnostics |

| claude update / claude install | Update to latest / install the native binary |

| claude setup-token | Generate a long-lived OAuth token for CI and scripts |

CLI flags worth knowing

Flag	What it does

| --print, -p | Print the response without interactive mode |

| --continue, -c | Load the most recent conversation in the current directory |

| --resume, -r | Resume a specific session by ID or name |

| --model | Set the model (alias or full name) |

| --permission-mode | Begin in a specific permission mode (e.g. plan, acceptEdits, auto) |

| --dangerously-skip-permissions | Skip permission prompts entirely (bypass mode — use with care) |

| --add-dir | Add extra working directories Claude can read and edit |

| --allowedTools / --disallowedTools | Allow tools without prompting / deny specific tools |

| --agents | Define custom subagents dynamically via JSON |

| --max-budget-usd | Cap the dollar spend on API calls before stopping |

| --max-turns | Limit the number of agentic turns |

| --effort | Set the effort level for the session |

| --fallback-model | Auto-fall back to another model when the primary is unavailable |

| --worktree, -w | Create and work in a git worktree |

| --output-format | Output format for print mode: text, json, stream-json |

| --verbose, -v | Verbose output |

Keyboard shortcuts

Key	What it does

| Esc | Interrupt Claude mid-turn (keeps work so far), or close an open dialog |

| Esc Esc | Clear the input draft; on an empty prompt, open the rewind menu |

| Shift+Tab | Cycle permission modes: default → acceptEdits → plan → (auto / bypass) |

| Ctrl+C | Interrupt a running op; if idle, first press clears input, second exits |

| Ctrl+D | Exit the session (double-press to confirm) |

| Ctrl+L | Redraw the screen (fix a garbled terminal); twice = /clear |

| Ctrl+R | Reverse-search command history |

| Ctrl+O | Toggle the transcript viewer (detailed tool usage) |

| Ctrl+B | Background running Bash tasks and agents |

| Ctrl+T | Toggle Claude's task checklist |

| Ctrl+V / Cmd+V | Paste an image from the clipboard as an [Image #N] chip |

| Option/Alt+P | Switch model without clearing your prompt |

| Option/Alt+T | Toggle extended thinking |

| Shift+Enter / Ctrl+J / \+Enter | Insert a newline (multiline input) |

| @ | Mention a file to attach it to the prompt |

| ! | Run a shell command inline (bash mode) |

| # | Add a line to CLAUDE.md memory |

The three that change how a session feels

Most people learn the commands and stop there. Three habits matter more than the rest.

Watch your context with /context, not by vibes. A bloated context window makes responses slower and worse. The colored grid shows exactly what is consuming tokens — old file reads, a long tool result, a verbose subagent — so you know whether to /compact or /clear. If you want to model the token cost before you run something big, our free AI token estimator gives you the number up front. The deeper mechanics of what actually costs tokens are in our breakdown of the Claude Code cost system.

Live in Shift+Tab. Cycling permission modes is the single biggest control on how autonomous a session feels — plan mode to think before touching code, acceptEdits to stop confirming every write, back to default when you want the brakes on. It is faster than reaching for a flag on restart.

Treat CLAUDE.md as the real interface. The # shortcut and /memory let you encode project rules once instead of re-explaining them every session. A well-built CLAUDE.md plus custom skills is what separates a tidy Claude Code setup from a chaotic one — it is the same discipline packaged in our Claude Code Production Pack, which ships the agents, skills, and rule files that run a real production repo. If you are wiring in your own tools, the MCP server build guide walks the TypeScript path.

Keep this handy

Bookmark this page and check /help in your install for anything version-specific — the surface moves fast, and this reflects Claude Code v2.1.x in 2026. The commands are free; the setup that makes them pay off is the part worth building.

Every Claude Code product mentioned is available at wowhow.cloud — pay once, ship forever.

Originally published at wowhow.cloud

Best AI Prompt Marketplaces in India (2026) — Compared

Anup Karanjkar — Tue, 04 Aug 2026 10:07:29 +0000

The best AI prompt marketplace for a buyer in India is the one whose checkout accepts ₹ over UPI. That sounds too simple, but it is the difference that decides the purchase. Most of the well-known prompt stores price in US dollars and settle only through international cards — which means a foreign-transaction fee, an FX markup, and for a lot of Indian debit cards, a declined payment at the last step. The size of the catalog barely matters if you cannot pay for it.

So this guide sorts the options by what an India buyer actually feels at checkout: currency, payment rails, and whether you pay once or sign up for a subscription. We cover PromptBase, Gumroad, Etsy, PromptHero, and WOWHOW. No affiliate spin — where a competitor is the better fit, we say so.

The comparison at a glance

Here is the structural reality of each marketplace for someone paying from India. These are the durable facts — checkout currency, native UPI support, and pricing model — not headline catalog counts that change weekly.

Marketplace	Checkout currency	Native UPI / ₹	Pricing model	Best for

| **WOWHOW** | **INR (₹)** | **Yes — UPI + Indian cards** | Pay once per pack | India buyers who want packs, not single prompts |

| PromptBase | USD ($) | No — international card | Pay per prompt | One-off, very specific single prompts |

| Gumroad | USD ($) | No — card / PayPal | Pay once (per creator) | Following a specific creator |

| Etsy | USD ($) | No — international card | Pay once | Niche / aesthetic prompt bundles |

| PromptHero | USD ($) | No — card | Subscription for Pro | Browsing AI-art prompts free |

One row is doing a lot of work there: the Native UPI column. Four of the five sell to India only through an international card. That is the gap this whole guide turns on.

PromptBase — the dedicated prompt store

PromptBase is the marketplace most people picture when they hear "buy a prompt." It is built specifically for prompts — you search by model (Midjourney, DALL·E, GPT, Stable Diffusion), preview an example output, and buy that single prompt. If you need one very specific thing — a particular illustration style, a niche copywriting angle — it is a reasonable place to find it.

The catch for an India buyer is entirely at checkout. Prices are in US dollars and payment runs through international card processing. There is no UPI option and no ₹ presentment, so a ₹ debit card either gets hit with a foreign-transaction fee or is declined outright. You are also buying one prompt at a time, which is fine for a single need and expensive if you want a working set.

Gumroad — creator storefronts, not a catalog

Gumroad is not a prompt marketplace; it is a checkout layer that individual creators use to sell digital products, prompts included. That is its strength and its weakness. If you already follow a specific prompt engineer whose style you trust, buying their pack on Gumroad is direct and clean. But there is no unified catalog to browse, no cross-seller search, and — again — pricing is in USD with card or PayPal settlement, not UPI.

For India buyers, Gumroad works best when you arrived with a specific creator in mind, not when you are shopping the field.

Etsy — prompts sold like craft downloads

Etsy sells AI prompts the same way it sells printables and templates: as digital downloads from independent sellers. You will find aesthetic, themed bundles here — wedding-invite art prompts, small-business branding sets — often nicely packaged. Quality is uneven because anyone can list, and discovery is built for crafts, not for filtering by model or use case.

Payment is USD via international card. For an occasional themed bundle it is fine; as a repeat source for working prompts, the checkout friction and the craft-first search get old.

PromptHero — discovery first, buying second

PromptHero is really a discovery engine for AI-art prompts. Browsing is free and genuinely useful when you want to see what a given image model can produce and reverse-engineer a look. The paid layer is a Pro subscription rather than a per-item purchase, and the focus is heavily image-generation. If your need is text, system, or workflow prompts, it is not aimed at you — and a subscription is the wrong shape for someone who wants one pack and out.

WOWHOW — priced in ₹, paid over UPI, bought as packs

Full disclosure: this is our store, so read the rest with that in mind — the facts here are ours to verify and yours to check. WOWHOW is built the opposite way to the USD-card default. Checkout is in INR, UPI is a first-class payment method alongside Indian cards, and every prompt product is pay-once — no subscription, no per-prompt nickel-and-diming. Instead of hunting single prompts, you buy curated packs organised by job.

Four collections cover the common needs. AI prompt packs are the general-purpose bundles. Image prompts target Midjourney/Stable-Diffusion-style generation. System prompt libraries are for anyone wiring prompts into an app or an agent. Content-writing prompts are for marketers and writers who want repeatable output.

Where WOWHOW is not the answer: if you need exactly one hyper-specific single prompt and nothing else, a per-prompt store like PromptBase can be cheaper for that one buy. We sell sets, not singles.

What actually matters for an India buyer

Strip away the branding and three things decide value for money from India.

Can you pay in ₹ over UPI? This is not a convenience footnote. An international-card purchase carries a foreign-transaction fee plus an FX conversion, and a meaningful share of Indian debit cards simply fail on foreign merchants. A ₹-priced, UPI-enabled checkout removes both the surcharge and the decline risk.

Pay once, or subscribe? For most people, prompts are a tool you buy and keep, not a service you rent. A subscription only makes sense if you are constantly consuming new prompts. If you want a pack and then to be left alone, pay-once wins.

Single prompts, or packs? Single-prompt buying looks cheap until you need five that work together. Packs cost more up front and less in total when your real need is a working set for a job.

Judge a prompt before you pay for it

Whatever store you use, do not buy blind. A prompt is only worth its price if it produces the output in the preview on your model, at a cost you accept. Two of our free tools help you check that without spending anything: the image prompt builder lets you assemble and test a structured image prompt before you go looking to buy one, and the AI prompt cost calculator estimates the token cost of running a prompt at scale so a "cheap" prompt does not turn into an expensive habit.

For a worked example of how much prompt structure changes output, our breakdown of ten image prompts on Gemini's Nano Banana shows the difference between a vague ask and an engineered one. If music is your thing, the Suno style-tag guide does the same for audio prompts.

The verdict

If you are buying from India and want packs you can pay for in rupees over UPI without an FX hit, WOWHOW is the straightest path — that is the exact gap it was built for. If you need a single, hyper-specific prompt and do not mind a USD card charge, PromptBase is the specialist. Gumroad is for when you are already loyal to one creator. Etsy suits the occasional themed bundle. PromptHero is the free browsing tool you keep open while you decide.

The honest summary: pick the marketplace by how you pay and how you buy, not by whose catalog claims the biggest number. For an India buyer, the payment rail is the product.

Every prompt pack mentioned from WOWHOW is available at wowhow.cloud — priced in ₹, paid over UPI, pay once and keep it.

Originally published at wowhow.cloud

Z.ai launches ZCode to challenge Cursor, Claude Code and GitHub Copilot in AI coding | VentureBeat

Anup Karanjkar — Fri, 31 Jul 2026 13:15:07 +0000

Z.ai launches ZCode to challenge Cursor, Claude Code and GitHub Copilot in AI coding | VentureBeat — this is a comprehensive guide covering everything you need to know.

What Is undefined?

[Explain the core concept in 2-3 paragraphs. Include practical context.]

How to Use undefined

[Step-by-step guide with examples. Include code snippets if relevant.]

Key Features and Benefits

[List 5-7 features with brief explanations.]

Common Mistakes to Avoid

[3-4 practical pitfalls and how to avoid them.]

Start with our free tool, then explore the comprehensive templates in the WOWHOW product catalog.

Originally published at wowhow.cloud

Income Tax Calculator India 2025-26: Complete Guide

Anup Karanjkar — Fri, 31 Jul 2026 05:44:56 +0000

Income Tax Calculator India 2025-26: Complete Guide — this is a comprehensive guide covering everything you need to know.

Try it yourself: Free Tax Regime Wizard (old vs new in 5 questions) — free, no signup, runs in your browser.

What Is income tax calculator?

[Explain the core concept in 2-3 paragraphs. Include practical context.]

How to Use income tax calculator

[Step-by-step guide with examples. Include code snippets if relevant.]

Key Features and Benefits

[List 5-7 features with brief explanations.]

Common Mistakes to Avoid

[3-4 practical pitfalls and how to avoid them.]

Start with our free tool, then explore the comprehensive templates in the WOWHOW product catalog.

Originally published at wowhow.cloud

Bash Scripting for DevOps: 20 Scripts That Automate Everything

Anup Karanjkar — Thu, 30 Jul 2026 19:16:45 +0000

Every production system has a graveyard of half-written Bash scripts that were good enough until they weren't. The patterns that separate robust shell automation from brittle one-liners are not complicated — they are just rarely taught together. This guide covers the idioms you need first, then 20 complete scripts for real DevOps workflows.

Try it yourself: Free Cron Expression Builder — free, no signup, runs in your browser.

Bash Scripting Fundamentals You Can't Skip

Every production Bash script should start with these three lines. They prevent silent failures, undefined variable bugs, and broken pipe errors from hiding real problems.

#!/usr/bin/env bash
set -euo pipefail
# -e: exit on any error
# -u: treat unset variables as errors
# -o pipefail: if any command in a pipeline fails, the pipeline fails
# Together these prevent scripts from continuing past errors silently

# Also useful for debugging:
# set -x    # Print each command before executing
# trap 'echo "Error on line $LINENO"' ERR  # More specific error info

Script 1: Service Health Check

#!/usr/bin/env bash
# scripts/health-check.sh — Check multiple services, alert on failure
set -euo pipefail

SERVICES=(
  "web:https://myapp.com/health:200"
  "api:https://api.myapp.com/health:200"
  "docs:https://docs.myapp.com/:200"
)
ALERT_EMAIL="${ALERT_EMAIL:-ops@myapp.com}"
SLACK_WEBHOOK="${SLACK_WEBHOOK:-}"
TIMEOUT=10
FAILED=0

check_service() {
  local name="$1" url="$2" expected_code="$3"
  local actual_code
  actual_code=$(curl -s -o /dev/null -w "%{http_code}" --max-time "$TIMEOUT" "$url" 2>/dev/null || echo "000")

  if [[ "$actual_code" == "$expected_code" ]]; then
    echo "  [OK]   $name ($url) → $actual_code"
    return 0
  else
    echo "  [FAIL] $name ($url) → expected $expected_code, got $actual_code"
    return 1
  fi
}

send_alert() {
  local message="$1"
  echo "$message"

  if [[ -n "$SLACK_WEBHOOK" ]]; then
    curl -s -X POST "$SLACK_WEBHOOK"       -H 'Content-type: application/json'       -d "{"text": "🚨 Health Check Failure\n$message"}"       > /dev/null
  fi
}

echo "Health check — $(date -u '+%Y-%m-%d %H:%M:%S UTC')"

for service_def in "${SERVICES[@]}"; do
  IFS=':' read -r name url expected /dev/null || echo 000)"
  fi
done

echo ""
if [[ $FAILED -eq 0 ]]; then
  echo "All services healthy."
  exit 0
else
  echo "$FAILED service(s) FAILED."
  exit 1
fi

Script 2: Log Rotation and Compression

#!/usr/bin/env bash
# scripts/rotate-logs.sh — Rotate, compress, and clean up application logs
set -euo pipefail

LOG_DIR="${LOG_DIR:-/var/log/myapp}"
RETENTION_DAYS="${RETENTION_DAYS:-14}"
MAX_SIZE_MB="${MAX_SIZE_MB:-100}"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

rotate_if_large() {
  local log_file="$1"
  local size_mb
  size_mb=$(du -m "$log_file" 2>/dev/null | cut -f1)

  if [[ $size_mb -ge $MAX_SIZE_MB ]]; then
    local rotated="${log_file}.${TIMESTAMP}"
    mv "$log_file" "$rotated"
    touch "$log_file"
    chmod 640 "$log_file"
    gzip "$rotated"
    echo "Rotated: $log_file (was ${size_mb}MB) → ${rotated}.gz"
    # Signal app to reopen log file
    if systemctl is-active --quiet myapp 2>/dev/null; then
      systemctl kill --kill-who=main --signal=USR1 myapp
    fi
  fi
}

cleanup_old_logs() {
  local count
  count=$(find "$LOG_DIR" -name "*.gz" -mtime +"$RETENTION_DAYS" | wc -l)
  if [[ $count -gt 0 ]]; then
    find "$LOG_DIR" -name "*.gz" -mtime +"$RETENTION_DAYS" -delete
    echo "Deleted $count log files older than $RETENTION_DAYS days"
  fi
}

if [[ ! -d "$LOG_DIR" ]]; then
  echo "Log directory $LOG_DIR does not exist" >&2
  exit 1
fi

echo "Log rotation — $(date -u)"
for log_file in "$LOG_DIR"/*.log; do
  [[ -f "$log_file" ]] && rotate_if_large "$log_file"
done
cleanup_old_logs
echo "Done. Disk usage: $(du -sh "$LOG_DIR" | cut -f1)"

Script 3: Automated PostgreSQL Backup

#!/usr/bin/env bash
# scripts/backup-postgres.sh — Full + incremental backups with S3 upload
set -euo pipefail

DB_HOST="${POSTGRES_HOST:-localhost}"
DB_PORT="${POSTGRES_PORT:-5432}"
DB_USER="${POSTGRES_USER:-postgres}"
DB_NAME="${POSTGRES_DB:-myapp}"
BACKUP_DIR="${BACKUP_DIR:-/backups/postgres}"
S3_BUCKET="${S3_BUCKET:-}"
RETENTION_DAYS=7
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="${BACKUP_DIR}/${DB_NAME}_${TIMESTAMP}.sql.gz"

mkdir -p "$BACKUP_DIR"

echo "[$(date -u)] Starting backup of $DB_NAME..."

# Perform the dump
PGPASSWORD="${POSTGRES_PASSWORD}" pg_dump   -h "$DB_HOST"   -p "$DB_PORT"   -U "$DB_USER"   -F plain   --no-owner   --no-acl   "$DB_NAME" | gzip -9 > "$BACKUP_FILE"

BACKUP_SIZE=$(du -sh "$BACKUP_FILE" | cut -f1)
echo "[$(date -u)] Backup complete: $BACKUP_FILE ($BACKUP_SIZE)"

# Verify the backup is valid gzip
if ! gzip -t "$BACKUP_FILE" 2>/dev/null; then
  echo "ERROR: Backup file is corrupted!" >&2
  rm -f "$BACKUP_FILE"
  exit 1
fi

# Upload to S3 if configured
if [[ -n "$S3_BUCKET" ]]; then
  aws s3 cp "$BACKUP_FILE" "s3://${S3_BUCKET}/postgres/$(basename "$BACKUP_FILE")"     --storage-class STANDARD_IA
  echo "Uploaded to S3: s3://${S3_BUCKET}/postgres/$(basename "$BACKUP_FILE")"
fi

# Cleanup old local backups
deleted=$(find "$BACKUP_DIR" -name "*.sql.gz" -mtime +"$RETENTION_DAYS" -print -delete | wc -l)
[[ $deleted -gt 0 ]] && echo "Deleted $deleted old backups"

echo "[$(date -u)] Backup finished."

Script 4: Zero-Downtime Deploy with Rollback

#!/usr/bin/env bash
# scripts/deploy.sh — Deploy with health check and automatic rollback
set -euo pipefail

APP_DIR="${APP_DIR:-/opt/myapp}"
COMPOSE_FILE="${APP_DIR}/docker-compose.yml"
HEALTH_URL="http://localhost:3000/health"
HEALTH_TIMEOUT=60
ROLLBACK_IMAGE="${APP_DIR}/.last-good-image"

log() { echo "[$(date -u '+%H:%M:%S')] $*"; }
fail() { echo "ERROR: $*" >&2; exit 1; }

# Save current image as rollback target
if [[ -f "$ROLLBACK_IMAGE" ]]; then
  PREVIOUS_IMAGE=$(cat "$ROLLBACK_IMAGE")
  log "Previous image: $PREVIOUS_IMAGE"
fi

rollback() {
  log "ROLLING BACK..."
  if [[ -f "$ROLLBACK_IMAGE" ]]; then
    local prev_image
    prev_image=$(cat "$ROLLBACK_IMAGE")
    docker tag "$prev_image" myapp:latest
    docker compose -f "$COMPOSE_FILE" up -d app
    log "Rolled back to $prev_image"
  else
    log "No rollback image available"
  fi
}

wait_healthy() {
  local timeout="$1"
  local elapsed=0
  log "Waiting for health check at $HEALTH_URL (timeout: ${timeout}s)..."

  while [[ $elapsed -lt $timeout ]]; do
    if curl -sf --max-time 5 "$HEALTH_URL" > /dev/null 2>&1; then
      log "Health check passed after ${elapsed}s"
      return 0
    fi
    sleep 5
    elapsed=$((elapsed + 5))
  done
  return 1
}

# Trap errors for rollback
trap 'log "Deploy failed. Running rollback..."; rollback; exit 1' ERR

log "Starting deploy..."

# Save current image for rollback
current_image=$(docker inspect --format='{{.Config.Image}}' myapp-app-1 2>/dev/null || echo "")
[[ -n "$current_image" ]] && echo "$current_image" > "$ROLLBACK_IMAGE"

# Pull new image
log "Pulling latest image..."
docker compose -f "$COMPOSE_FILE" pull app

# Rolling restart (start new, wait healthy, remove old)
log "Starting new container..."
docker compose -f "$COMPOSE_FILE" up -d --no-deps app

if ! wait_healthy "$HEALTH_TIMEOUT"; then
  fail "Health check timed out after ${HEALTH_TIMEOUT}s"
fi

log "Deploy successful!"

Script 5: Disk Space Monitoring with Alerts

#!/usr/bin/env bash
# scripts/disk-monitor.sh — Alert when disk usage exceeds threshold
set -euo pipefail

THRESHOLD_WARN=75
THRESHOLD_CRIT=90
SLACK_WEBHOOK="${SLACK_WEBHOOK:-}"
HOSTNAME_ALIAS="${HOSTNAME_ALIAS:-$(hostname)}"

check_disk() {
  while IFS= read -r line; do
    local usage mount
    usage=$(echo "$line" | awk '{print $5}' | tr -d '%')
    mount=$(echo "$line" | awk '{print $6}')

    if [[ $usage -ge $THRESHOLD_CRIT ]]; then
      alert "CRITICAL" "$mount" "$usage"
    elif [[ $usage -ge $THRESHOLD_WARN ]]; then
      alert "WARNING" "$mount" "$usage"
    fi
  done  /dev/null
  fi
}

check_disk

Script 6: Redis Memory Check and Eviction Policy Monitor

#!/usr/bin/env bash
# scripts/redis-check.sh — Monitor Redis memory, keys, and hit rate
set -euo pipefail

REDIS_CLI="${REDIS_CLI:-redis-cli}"
REDIS_AUTH="${REDIS_PASSWORD:-}"
AUTH_FLAG=$( [[ -n "$REDIS_AUTH" ]] && echo "-a $REDIS_AUTH" || echo "" )

redis_cmd() {
  # shellcheck disable=SC2086
  $REDIS_CLI $AUTH_FLAG "$@" 2>/dev/null
}

echo "=== Redis Status Report — $(date -u) ==="

# Memory
used_mb=$(redis_cmd info memory | grep "used_memory_human" | cut -d: -f2 | tr -d '
')
max_mb=$(redis_cmd info memory | grep "maxmemory_human" | cut -d: -f2 | tr -d '
')
echo "Memory: $used_mb / $max_mb"

# Hit rate
hits=$(redis_cmd info stats | grep "keyspace_hits:" | cut -d: -f2 | tr -d '
')
misses=$(redis_cmd info stats | grep "keyspace_misses:" | cut -d: -f2 | tr -d '
')
if [[ $((hits + misses)) -gt 0 ]]; then
  hit_rate=$(echo "scale=1; $hits * 100 / ($hits + $misses)" | bc)
  echo "Cache hit rate: ${hit_rate}% ($hits hits, $misses misses)"
fi

# Keyspace
redis_cmd info keyspace

# Eviction policy
policy=$(redis_cmd config get maxmemory-policy | tail -1)
echo "Eviction policy: $policy"

# Connected clients
clients=$(redis_cmd info clients | grep "connected_clients:" | cut -d: -f2 | tr -d '
')
echo "Connected clients: $clients"

# Top key prefixes (by count)
echo ""
echo "=== Key prefix breakdown ==="
redis_cmd --scan | sed 's/:.*//' | sort | uniq -c | sort -rn | head -10

Script 7: Cron Job Wrapper with Logging and Lock

#!/usr/bin/env bash
# scripts/cron-wrapper.sh — Run any cron job with locking, logging, timeout
# Usage: cron-wrapper.sh    [args...]
set -euo pipefail

JOB_NAME="$1"; shift
TIMEOUT="$1"; shift
COMMAND="$@"

LOCK_FILE="/tmp/cron-lock-${JOB_NAME}"
LOG_FILE="/var/log/cron/${JOB_NAME}.log"
MAX_LOG_LINES=10000

mkdir -p "$(dirname "$LOG_FILE")"

log() { echo "[$(date -u '+%Y-%m-%d %H:%M:%S')] [$JOB_NAME] $*" | tee -a "$LOG_FILE"; }

# Exclusive lock — skip if already running
exec 9>"$LOCK_FILE"
if ! flock --nonblock 9; then
  log "Skipping: already running (lock held)"
  exit 0
fi

log "START: $COMMAND"
START_TIME=$(date +%s)

# Run with timeout
if timeout "$TIMEOUT" bash -c "$COMMAND" >> "$LOG_FILE" 2>&1; then
  EXIT_CODE=0
else
  EXIT_CODE=$?
fi

ELAPSED=$(($(date +%s) - START_TIME))

if [[ $EXIT_CODE -eq 0 ]]; then
  log "OK: completed in ${ELAPSED}s"
elif [[ $EXIT_CODE -eq 124 ]]; then
  log "TIMEOUT after ${TIMEOUT}s"
else
  log "FAILED with exit code $EXIT_CODE after ${ELAPSED}s"
fi

# Trim log file
if [[ $(wc -l  "${LOG_FILE}.tmp" && mv "${LOG_FILE}.tmp" "$LOG_FILE"
fi

exit $EXIT_CODE

Cron Patterns That Actually Work

# /etc/cron.d/myapp — Production cron definitions

# Health check every 5 minutes
*/5 * * * * deploy /opt/myapp/scripts/cron-wrapper.sh health-check 30 /opt/myapp/scripts/health-check.sh

# Database backup daily at 2am UTC
0 2 * * * deploy /opt/myapp/scripts/cron-wrapper.sh postgres-backup 600 /opt/myapp/scripts/backup-postgres.sh

# Log rotation daily at 3am
0 3 * * * root /opt/myapp/scripts/rotate-logs.sh

# Disk check every 15 minutes
*/15 * * * * root /opt/myapp/scripts/disk-monitor.sh

# Redis check hourly
0 * * * * deploy /opt/myapp/scripts/redis-check.sh >> /var/log/redis-check.log 2>&1

# View counter flush every 30 seconds via a looping script (not cron)
# See write-behind pattern above

Script 8: Environment Variable Validation at Startup

#!/usr/bin/env bash
# scripts/validate-env.sh — Fail fast if required vars are missing
set -euo pipefail

REQUIRED_VARS=(
  "DATABASE_URL"
  "REDIS_URL"
  "JWT_SECRET"
  "NODE_ENV"
  "PORT"
)

OPTIONAL_VARS=(
  "SLACK_WEBHOOK"
  "SENTRY_DSN"
  "S3_BUCKET"
)

MISSING=0
for var in "${REQUIRED_VARS[@]}"; do
  if [[ -z "${!var:-}" ]]; then
    echo "ERROR: Required environment variable '$var' is not set" >&2
    MISSING=$((MISSING + 1))
  fi
done

for var in "${OPTIONAL_VARS[@]}"; do
  if [[ -z "${!var:-}" ]]; then
    echo "WARN: Optional variable '$var' is not set"
  fi
done

if [[ $MISSING -gt 0 ]]; then
  echo "$MISSING required variable(s) missing. Aborting." >&2
  exit 1
fi

echo "All required environment variables are set."

Ready-to-deploy Bash script libraries, DevOps automation templates, and monitoring starter kits are at WOWHOW developer tools. Browse all DevOps and automation resources at wowhow.cloud/browse.

Originally published at wowhow.cloud

Redis Caching Patterns for Node.js: Cache-Aside, Write-Through & More

Anup Karanjkar — Thu, 30 Jul 2026 19:16:10 +0000

Redis caching is one of those things where the first 20% of the work gives you 80% of the benefit and the remaining 80% of the work prevents the 20% of cases that cause incidents. The cache-aside pattern is simple. Cache invalidation is famously hard. This guide covers both, plus write-through, write-behind, TTL strategies, cache warming, and the pub/sub patterns that let multiple services stay in sync.

Try it yourself: Free .env File Converter — free, no signup, runs in your browser.

Redis Client Setup for Production

Use ioredis for Node.js — it handles reconnection, cluster mode, Sentinel, and has better TypeScript support than the official redis package.

// src/cache/redis-client.ts
import Redis, { type RedisOptions } from 'ioredis'
import { logger } from '../utils/logger'

const options: RedisOptions = {
  host: process.env.REDIS_HOST ?? 'localhost',
  port: Number(process.env.REDIS_PORT ?? 6379),
  password: process.env.REDIS_PASSWORD,
  db: Number(process.env.REDIS_DB ?? 0),

  // Connection pool
  maxRetriesPerRequest: 3,
  retryStrategy: (times: number) => {
    if (times > 10) return null  // Stop retrying after 10 attempts
    return Math.min(times * 100, 3000)  // Exponential backoff, cap at 3s
  },

  // Timeouts
  connectTimeout: 5000,
  commandTimeout: 2000,

  // Reconnect on error (e.g., READONLY error in replica failover)
  reconnectOnError: (err: Error) => {
    const targetErrors = ['READONLY', 'ECONNRESET', 'ETIMEDOUT']
    return targetErrors.some((e) => err.message.includes(e))
  },

  lazyConnect: true,
  enableAutoPipelining: true,  // Batch commands automatically
}

export const redis = new Redis(options)

redis.on('connect', () => logger.info('Redis connected'))
redis.on('error', (err) => logger.error({ err }, 'Redis error'))
redis.on('reconnecting', (delay: number) => logger.warn({ delay }, 'Redis reconnecting'))

// Typed wrapper with automatic JSON serialization
export class RedisCache {
  constructor(
    private readonly client: Redis,
    private readonly defaultTTL: number = 3600,
  ) {}

  async get(key: string): Promise {
    const raw = await this.client.get(key)
    if (raw === null) return null
    try {
      return JSON.parse(raw) as T
    } catch {
      return raw as unknown as T
    }
  }

  async set(key: string, value: T, ttlSeconds?: number): Promise {
    const serialized = JSON.stringify(value)
    const ttl = ttlSeconds ?? this.defaultTTL
    await this.client.setex(key, ttl, serialized)
  }

  async del(...keys: string[]): Promise {
    if (keys.length === 0) return 0
    return this.client.del(...keys)
  }

  async exists(key: string): Promise {
    const count = await this.client.exists(key)
    return count > 0
  }

  async ttl(key: string): Promise {
    return this.client.ttl(key)
  }
}

export const cache = new RedisCache(redis)

Cache-Aside Pattern (Lazy Loading)

Cache-aside is the most common pattern: the application checks the cache first, fetches from the database on a miss, and writes the result back to the cache. The cache never holds data the application hasn't explicitly put there.

// src/services/product-service.ts
import { prisma } from '../db/prisma'
import { cache } from '../cache/redis-client'
import type { Product } from '@prisma/client'

const PRODUCT_TTL = 600  // 10 minutes
const productKey = (id: string) => `product:v1:${id}`

export class ProductService {
  async getById(id: string): Promise
 {
    const key = productKey(id)

    // 1. Check cache
    const cached = await cache.get(key)
    if (cached !== null) {
      return cached
    }

    // 2. Cache miss — fetch from database
    const product = await prisma.product.findUnique({ where: { id } })

    // 3. Write to cache (only if found — don't cache null/404)
    if (product !== null) {
      await cache.set(key, product, PRODUCT_TTL)
    }

    return product
  }

  async update(id: string, data: Partial): Promise {
    const updated = await prisma.product.update({ where: { id }, data })

    // Invalidate cache after write
    await cache.del(productKey(id))

    return updated
  }

  async delete(id: string): Promise {
    await prisma.product.delete({ where: { id } })
    await cache.del(productKey(id))
  }
}

// Generic cache-aside helper for any async function
export async function cacheAside(
  key: string,
  fetcher: () => Promise,
  ttlSeconds: number = 600,
): Promise {
  const cached = await cache.get(key)
  if (cached !== null) return cached

  const value = await fetcher()
  if (value !== null) {
    await cache.set(key, value, ttlSeconds)
  }
  return value
}

Write-Through Pattern

Write-through updates the cache synchronously on every write, so the cache always reflects the database. Best for read-heavy data that must never be stale. The cost is write latency (two writes per update).

// src/services/user-session-service.ts — write-through for sessions
import { cache } from '../cache/redis-client'
import { prisma } from '../db/prisma'
import type { UserSession } from '@prisma/client'

const SESSION_TTL = 86400 * 7  // 7 days
const sessionKey = (token: string) => `session:v1:${token}`

export class UserSessionService {
  async create(userId: string, token: string, metadata: object): Promise {
    const expiresAt = new Date(Date.now() + SESSION_TTL * 1000)

    // Write to DB and cache together
    const [session] = await Promise.all([
      prisma.userSession.create({
        data: { userId, token, metadata, expiresAt },
      }),
      cache.set(sessionKey(token), { userId, metadata, expiresAt }, SESSION_TTL),
    ])

    return session
  }

  async getByToken(token: string): Promise {
    // Try cache first (will almost always hit for active sessions)
    const cached = await cache.get(sessionKey(token))
    if (cached) return cached

    // Fallback: DB + re-populate cache
    const session = await prisma.userSession.findUnique({ where: { token } })
    if (session && session.expiresAt > new Date()) {
      const remainingTTL = Math.floor((session.expiresAt.getTime() - Date.now()) / 1000)
      await cache.set(sessionKey(token), session, remainingTTL)
    }
    return session
  }

  async revoke(token: string): Promise {
    await Promise.all([
      prisma.userSession.delete({ where: { token } }),
      cache.del(sessionKey(token)),
    ])
  }
}

Write-Behind (Write-Back) Pattern

Write-behind writes to the cache immediately and defers the database write. This dramatically improves write throughput for high-frequency updates like view counts, likes, or analytics events. The trade-off is data loss risk on crash before the flush.

// src/services/view-counter-service.ts — write-behind for analytics
import { redis } from '../cache/redis-client'
import { prisma } from '../db/prisma'

const viewCountKey = (postId: string) => `views:pending:${postId}`
const FLUSH_INTERVAL_MS = 30_000  // Flush every 30 seconds
const FLUSH_BATCH_SIZE = 100

export class ViewCounterService {
  // Increment in Redis only — fast, no DB hit
  async increment(postId: string): Promise {
    await redis.incr(viewCountKey(postId))
  }

  async get(postId: string): Promise {
    const pending = await redis.get(viewCountKey(postId))
    const dbCount = await prisma.post.findUnique({
      where: { id: postId },
      select: { viewCount: true },
    })
    return (dbCount?.viewCount ?? 0) + Number(pending ?? 0)
  }

  // Run this on a schedule (e.g., every 30 seconds via setInterval or cron)
  async flushToDatabase(): Promise {
    const keys = await redis.keys('views:pending:*')
    if (keys.length === 0) return

    // Process in batches
    for (let i = 0; i  pipeline.getdel(key))
      const results = await pipeline.exec()

      const updates = batch
        .map((key, idx) => ({
          postId: key.replace('views:pending:', ''),
          count: Number(results?.[idx]?.[1] ?? 0),
        }))
        .filter((u) => u.count > 0)

      await Promise.all(
        updates.map(({ postId, count }) =>
          prisma.post.update({
            where: { id: postId },
            data: { viewCount: { increment: count } },
          }),
        ),
      )
    }
  }
}

// Start the flush interval
const viewCounter = new ViewCounterService()
setInterval(() => viewCounter.flushToDatabase().catch(console.error), FLUSH_INTERVAL_MS)

Cache Invalidation: Tag-Based Strategy

Tag-based invalidation groups related cache keys under a tag, so you can invalidate all of them atomically. This solves the problem of "product updated — which cache keys hold product data?"

// src/cache/tag-invalidation.ts
import { redis } from './redis-client'

const tagSetKey = (tag: string) => `cache-tag:${tag}`

export class TaggedCache {
  async set(
    key: string,
    value: T,
    options: { ttl?: number; tags?: string[] } = {},
  ): Promise {
    const { ttl = 600, tags = [] } = options
    const pipeline = redis.pipeline()

    pipeline.setex(key, ttl, JSON.stringify(value))

    // Register this key under each tag
    for (const tag of tags) {
      pipeline.sadd(tagSetKey(tag), key)
      pipeline.expire(tagSetKey(tag), ttl + 60)  // Tag outlives the cached values
    }

    await pipeline.exec()
  }

  async invalidateTag(tag: string): Promise {
    const tagKey = tagSetKey(tag)
    const keys = await redis.smembers(tagKey)

    if (keys.length === 0) return 0

    const pipeline = redis.pipeline()
    keys.forEach((key) => pipeline.del(key))
    pipeline.del(tagKey)
    await pipeline.exec()

    return keys.length
  }
}

// Usage:
const taggedCache = new TaggedCache()

// Cache product with tags
await taggedCache.set(`product:${product.id}`, product, {
  ttl: 600,
  tags: [`product:${product.id}`, `category:${product.categoryId}`, 'products'],
})

// Invalidate everything in a category
await taggedCache.invalidateTag(`category:${categoryId}`)
// All product caches, listing caches, etc. for that category are gone

Pub/Sub for Cache Synchronization Across Instances

// src/cache/cache-invalidation-bus.ts
// When running multiple app instances, one instance updating DB must
// tell all other instances to drop their local in-memory caches.
import Redis from 'ioredis'

const INVALIDATION_CHANNEL = 'cache:invalidation'

// Separate connection for pub/sub (subscriber blocks the connection)
const subscriber = new Redis({
  host: process.env.REDIS_HOST,
  password: process.env.REDIS_PASSWORD,
})
const publisher = new Redis({
  host: process.env.REDIS_HOST,
  password: process.env.REDIS_PASSWORD,
})

type InvalidationMessage = {
  type: 'key' | 'tag' | 'pattern'
  value: string
  instanceId: string
}

const LOCAL_INSTANCE_ID = process.env.HOSTNAME ?? Math.random().toString(36).slice(2)
const listeners = new Set void>()

subscriber.subscribe(INVALIDATION_CHANNEL, (err) => {
  if (err) console.error('Cache invalidation subscribe error:', err)
})

subscriber.on('message', (_channel: string, message: string) => {
  try {
    const msg = JSON.parse(message) as InvalidationMessage
    if (msg.instanceId !== LOCAL_INSTANCE_ID) {
      listeners.forEach((listener) => listener(msg))
    }
  } catch {}
})

export function onCacheInvalidation(listener: (msg: InvalidationMessage) => void): () => void {
  listeners.add(listener)
  return () => listeners.delete(listener)
}

export async function publishCacheInvalidation(
  type: InvalidationMessage['type'],
  value: string,
): Promise {
  const msg: InvalidationMessage = { type, value, instanceId: LOCAL_INSTANCE_ID }
  await publisher.publish(INVALIDATION_CHANNEL, JSON.stringify(msg))
}

Redis implementation templates, Node.js caching boilerplates, and production starter kits are at WOWHOW developer tools. See the full catalog at wowhow.cloud/browse.

Originally published at wowhow.cloud

Git Advanced Commands: Rebase, Cherry-Pick, Bisect & Interactive Workflows

Anup Karanjkar — Thu, 30 Jul 2026 19:15:37 +0000

Most developers use about 20% of Git and fight the other 80%. Interactive rebase feels dangerous until you understand what it does. Cherry-pick seems redundant until you need to backport a fix to three release branches simultaneously. Bisect looks academic until you are staring at a regression that could be in any of 200 commits. This guide covers the commands that save hours when you need them.

Try it yourself: Free Diff Checker — free, no signup, runs in your browser.

Interactive Rebase: Clean History Before Merging

Interactive rebase lets you rewrite the commit history of your branch before it merges into main. The goal is a clean, reviewable history — not a forensic record of every save-and-test cycle.

# Start interactive rebase against the branch point
git rebase -i main

# Or rebase the last N commits
git rebase -i HEAD~5

# Or rebase from a specific commit (not including it)
git rebase -i abc1234

The interactive editor opens with a list of commits and commands. The most useful commands:

# Commands available in the interactive rebase editor:
pick abc1234 Add user authentication endpoint    # keep as-is
reword def5678 Fix typo in validator              # keep, but edit the message
edit 789abcd Add Redis caching layer              # pause here to amend
squash bcd1234 WIP: cache working                # meld into previous commit
fixup cde5678 fix lint error                     # meld into prev, discard message
drop ef01234 Remove debug console.log            # delete this commit entirely
exec npm test                                     # run a command between commits

Real-world squash workflow: you have a feature branch with 8 commits, 3 of which are "fix lint" and "WIP". Before raising a PR:

# See what you have
git log --oneline main..HEAD

# a3f1c2d Add user profile endpoint
# b4e2d3e Add profile schema
# c5f3e4f WIP saving
# d6g4f5g Fix tests
# e7h5g6h Fix more tests
# f8i6h7i Fix lint
# g9j7i8j Add profile validation
# h0k8j9k Fix validation edge case

# Rebase interactively — 8 commits
git rebase -i HEAD~8

After the editor, the result is 2-3 logical commits with meaningful messages. Reviewers see the intent, not the iteration.

Rebase vs Merge: When to Use Each

# Merge: preserves full history, creates a merge commit
git checkout main
git merge feature/user-profile
# Result: non-linear history, shows exactly when branches diverged/merged

# Rebase: replays your commits on top of main, linear history
git checkout feature/user-profile
git rebase main
# Result: your commits appear after all of main's commits, no merge commit

# After rebasing a feature branch, merge with --no-ff to preserve the branch point
git checkout main
git merge --no-ff feature/user-profile

# Fast-forward only (use when you want to enforce rebase workflow)
git merge --ff-only feature/user-profile
# Fails if there are divergent commits, forcing a rebase first

Handling Rebase Conflicts

# Conflict during rebase — Git pauses and tells you which file
git rebase main
# CONFLICT (content): Merge conflict in src/auth/middleware.ts
# error: could not apply a3f1c2d... Add JWT middleware

# 1. Fix the conflict in the file
# 2. Stage it
git add src/auth/middleware.ts

# 3. Continue the rebase (NOT git commit!)
git rebase --continue

# Made a mistake? Abort and return to original state
git rebase --abort

# Skip a commit entirely (be careful — you might lose changes)
git rebase --skip

Cherry-Pick: Surgical Commit Transplants

Cherry-pick copies one or more commits from one branch to another. The primary use case is hotfix backporting: a bug is fixed on main and needs to go into the release/1.x and release/2.x branches without merging unrelated changes.

# Cherry-pick a single commit
git cherry-pick a3f1c2d

# Cherry-pick a range of commits (inclusive)
git cherry-pick a3f1c2d..h0k8j9k

# Cherry-pick without committing (stage the changes, let you review first)
git cherry-pick --no-commit a3f1c2d

# Cherry-pick and edit the commit message
git cherry-pick --edit a3f1c2d

# Backport workflow: fix is on main, need it on release/1.x
git log --oneline -5 main
# a3f1c2d Fix SQL injection in user search (this is the fix)

git checkout release/1.x
git cherry-pick a3f1c2d
# If it applies cleanly: done. If conflict: resolve like a rebase conflict.

# Cherry-pick multiple specific commits
git cherry-pick a3f1c2d b4e2d3e c5f3e4f

Git Bisect: Binary Search for Regressions

Bisect performs a binary search through your commit history to find which commit introduced a bug. Given a "good" commit and a "bad" commit, it checks out the midpoint, asks you to test, and narrows down to the exact commit in O(log n) steps.

# Start bisect
git bisect start

# Mark current state as bad (the bug exists)
git bisect bad HEAD

# Mark the last known good commit (tests passed)
git bisect good v2.3.0
# or by commit hash:
git bisect good abc1234

# Git checks out the midpoint commit. Test it, then:
git bisect bad   # if the bug exists here
git bisect good  # if the bug does not exist here

# Git keeps narrowing down. After 7-8 steps for 100 commits, you get:
# a3f1c2d is the first bad commit
# commit a3f1c2d
# Author: Dev Name 
# Date: ...
#     Refactor user search to use LIKE query

# Clean up — return to HEAD
git bisect reset

Automated bisect with a test script. This is the power mode — bisect runs the script at each step:

# Write a test script that exits 0 for good, non-zero for bad
cat > /tmp/test-regression.sh /dev/null || exit 125  # skip un-buildable commits
npm test -- --testPathPattern="user-search" --silent 2>/dev/null
SCRIPT
chmod +x /tmp/test-regression.sh

# Run automated bisect
git bisect start
git bisect bad HEAD
git bisect good v2.3.0
git bisect run /tmp/test-regression.sh
# Git runs the script at each midpoint and narrows down automatically
# Exit 125 means "skip this commit" (use for broken builds that aren't the bug)

# When done
git bisect reset

Reflog: Recovering Lost Work

The reflog is Git's safety net. Every time HEAD moves — commit, checkout, rebase, reset — Git records it. You can recover from almost any disaster if you act quickly.

# View the reflog
git reflog
# HEAD@{0}: rebase (finish): returning to refs/heads/feature/auth
# HEAD@{1}: rebase (pick): Add JWT middleware
# HEAD@{2}: rebase (pick): Add auth schema
# HEAD@{3}: rebase (start): checkout main
# HEAD@{4}: commit: WIP save before rebase
# HEAD@{5}: checkout: moving from main to feature/auth

# Recover a commit after accidental reset --hard
git reset --hard HEAD~3   # oops, went back 3 commits
git reflog                # find the commit you were at
git reset --hard HEAD@{3} # restore to that point

# Recover a deleted branch
git branch -D feature/old-work  # oops
git reflog | grep "feature/old-work"
# HEAD@{12}: checkout: moving from feature/old-work to main
git checkout -b feature/old-work HEAD@{12}

# Find a dangling commit (detached HEAD work that got lost)
git fsck --lost-found
# Lists unreachable commits, blobs
git show 
git cherry-pick

Git Worktrees: Multiple Branches Simultaneously

Worktrees let you check out multiple branches in separate directories simultaneously. No stashing, no context switching — open a hotfix in a new directory while keeping your feature branch untouched.

# List existing worktrees
git worktree list

# Add a worktree for a hotfix
git worktree add ../myapp-hotfix release/1.x
# Creates ../myapp-hotfix/ directory checked out to release/1.x

# Work in the hotfix worktree
cd ../myapp-hotfix
git checkout -b hotfix/sql-injection
# ... make fixes ...
git commit -m "fix(auth): patch SQL injection in user search"

# Back in main worktree, cherry-pick if needed
cd ../myapp
git cherry-pick hotfix/sql-injection

# Remove worktree when done
git worktree remove ../myapp-hotfix

Advanced Log and Diff Commands

# Compact, visual branch graph
git log --oneline --graph --decorate --all

# Find commits that changed a specific file
git log --follow -p -- src/auth/middleware.ts

# Find commits by message content
git log --grep="SQL injection" --oneline

# Find commits by author in a date range
git log --author="dev" --since="2 weeks ago" --oneline

# Show what changed between two branches
git diff main..feature/auth --stat

# Show commits in feature/auth not in main
git log main..feature/auth --oneline

# Find which branch a commit is on
git branch --contains a3f1c2d

# Show the diff of a specific commit
git show a3f1c2d

# Show files changed in a commit
git show --stat a3f1c2d

# Diff between two tags
git diff v2.3.0..v2.4.0 -- src/

For Git workflow templates, CI/CD setup guides, and developer automation tools, visit WOWHOW developer tools. Browse all productivity and DevOps resources at the full catalog.

Originally published at wowhow.cloud

Docker Compose for Production: Node.js + Redis + PostgreSQL Stack

Anup Karanjkar — Thu, 30 Jul 2026 19:15:05 +0000

Docker Compose is excellent for production when you use it correctly. The common failure modes — services starting before their dependencies are ready, secrets in environment variables visible in docker inspect, single-layer images that are 1.2GB, no memory limits causing OOM kills, volumes with no backup strategy — are all avoidable with the right configuration.

This guide walks through a complete production-grade Node.js + Redis + PostgreSQL stack. Every configuration choice here addresses a real failure mode.

Try it yourself: Free .env File Converter — free, no signup, runs in your browser.

Multi-Stage Dockerfile: Node.js

A naive Node.js Dockerfile copies everything and installs all dependencies in one layer. The result is a 1GB+ image with dev dependencies, source maps, and unnecessary files. Multi-stage builds produce images under 200MB with only what production needs.

# Dockerfile
# Stage 1: Install all dependencies (including dev)
FROM node:22-alpine AS deps
WORKDIR /app

# Copy package files first for layer caching
COPY package*.json ./
COPY prisma ./prisma/

# Install all deps including devDeps for build
RUN npm ci --frozen-lockfile

# Stage 2: Build the application
FROM node:22-alpine AS builder
WORKDIR /app

COPY --from=deps /app/node_modules ./node_modules
COPY . .

# Generate Prisma client
RUN npx prisma generate

# Build TypeScript
RUN npm run build

# Stage 3: Production image — only runtime artifacts
FROM node:22-alpine AS runner
WORKDIR /app

ENV NODE_ENV=production

# Security: run as non-root
RUN addgroup --system --gid 1001 nodejs &&     adduser --system --uid 1001 --ingroup nodejs nodeuser

# Copy only what production needs
COPY --from=builder --chown=nodeuser:nodejs /app/dist ./dist
COPY --from=builder --chown=nodeuser:nodejs /app/node_modules ./node_modules
COPY --from=builder --chown=nodeuser:nodejs /app/prisma ./prisma
COPY --chown=nodeuser:nodejs package.json ./

USER nodeuser

EXPOSE 3000

# Use exec form to handle signals properly (not shell form)
CMD ["node", "dist/server.js"]

HEALTHCHECK --interval=15s --timeout=5s --start-period=30s --retries=3   CMD wget -qO /dev/null http://localhost:3000/health || exit 1

Complete docker-compose.yml for Production

# docker-compose.yml
name: myapp

services:
  # --- PostgreSQL ---
  postgres:
    image: postgres:16-alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: ${POSTGRES_DB:-myapp}
      POSTGRES_USER: ${POSTGRES_USER:-myapp}
      POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
    secrets:
      - postgres_password
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./db/init:/docker-entrypoint-initdb.d:ro
    networks:
      - backend
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-myapp} -d ${POSTGRES_DB:-myapp}"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s
    deploy:
      resources:
        limits:
          cpus: "1.0"
          memory: 512M
        reservations:
          memory: 256M

  # --- Redis ---
  redis:
    image: redis:7-alpine
    restart: unless-stopped
    command: >
      redis-server
      --requirepass-file /run/secrets/redis_password
      --maxmemory 256mb
      --maxmemory-policy allkeys-lru
      --save 60 1000
      --appendonly yes
    secrets:
      - redis_password
    volumes:
      - redis_data:/data
    networks:
      - backend
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "$(cat /run/secrets/redis_password)", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 15s
    deploy:
      resources:
        limits:
          cpus: "0.5"
          memory: 384M

  # --- Database migrations (run-once job) ---
  migrator:
    build:
      context: .
      dockerfile: Dockerfile
      target: builder
    command: npx prisma migrate deploy
    environment:
      DATABASE_URL: "postgresql://${POSTGRES_USER:-myapp}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-myapp}"
    secrets:
      - postgres_password
    depends_on:
      postgres:
        condition: service_healthy
    networks:
      - backend
    restart: "no"

  # --- Application ---
  app:
    build:
      context: .
      dockerfile: Dockerfile
      target: runner
      cache_from:
        - type=registry,ref=myregistry.io/myapp:buildcache
      cache_to:
        - type=registry,ref=myregistry.io/myapp:buildcache,mode=max
    image: myregistry.io/myapp:latest
    restart: unless-stopped
    environment:
      NODE_ENV: production
      PORT: "3000"
      DATABASE_URL_FILE: /run/secrets/database_url
      REDIS_URL_FILE: /run/secrets/redis_url
      JWT_SECRET_FILE: /run/secrets/jwt_secret
    secrets:
      - database_url
      - redis_url
      - jwt_secret
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      migrator:
        condition: service_completed_successfully
    networks:
      - backend
      - frontend
    healthcheck:
      test: ["CMD", "wget", "-qO", "/dev/null", "http://localhost:3000/health"]
      interval: 15s
      timeout: 5s
      retries: 3
      start_period: 30s
    deploy:
      replicas: 2
      update_config:
        parallelism: 1
        delay: 15s
        failure_action: rollback
        order: start-first
      rollback_config:
        parallelism: 1
        delay: 10s
      resources:
        limits:
          cpus: "1.0"
          memory: 512M
        reservations:
          cpus: "0.25"
          memory: 128M
    logging:
      driver: "json-file"
      options:
        max-size: "50m"
        max-file: "5"

  # --- Nginx reverse proxy ---
  nginx:
    image: nginx:1.25-alpine
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/conf.d:/etc/nginx/conf.d:ro
      - certbot_www:/var/www/certbot:ro
      - certbot_conf:/etc/letsencrypt:ro
    depends_on:
      app:
        condition: service_healthy
    networks:
      - frontend
    healthcheck:
      test: ["CMD", "nginx", "-t"]
      interval: 30s
      timeout: 10s

volumes:
  postgres_data:
    driver: local
  redis_data:
    driver: local
  certbot_www:
  certbot_conf:

networks:
  backend:
    driver: bridge
    internal: true   # No direct internet access
  frontend:
    driver: bridge

secrets:
  postgres_password:
    file: ./secrets/postgres_password.txt
  redis_password:
    file: ./secrets/redis_password.txt
  database_url:
    file: ./secrets/database_url.txt
  redis_url:
    file: ./secrets/redis_url.txt
  jwt_secret:
    file: ./secrets/jwt_secret.txt

Reading Docker Secrets in Node.js

Docker secrets are mounted as files under /run/secrets/. Reading them at startup prevents secrets from appearing in docker inspect environment variables.

// src/config/secrets.ts
import { readFileSync } from 'fs'

function readSecret(envVar: string, secretFile?: string): string {
  // First try the _FILE variant (Docker secrets pattern)
  const fileEnvVar = `${envVar}_FILE`
  const filePath = process.env[fileEnvVar] ?? secretFile

  if (filePath) {
    try {
      return readFileSync(filePath, 'utf-8').trim()
    } catch (err) {
      // Fall through to direct env var
    }
  }

  const value = process.env[envVar]
  if (!value) {
    throw new Error(`Required secret '${envVar}' is not set (checked ${fileEnvVar} and ${envVar})`)
  }
  return value
}

export const secrets = {
  databaseUrl: readSecret('DATABASE_URL'),
  redisUrl: readSecret('REDIS_URL'),
  jwtSecret: readSecret('JWT_SECRET'),
} as const

Health Check Endpoint

// src/routes/health.ts
import type { FastifyInstance } from 'fastify'
import { prisma } from '../db/prisma'
import { redis } from '../cache/redis'

interface HealthStatus {
  status: 'ok' | 'degraded' | 'down'
  checks: Record
  uptime: number
  timestamp: string
}

export async function healthRoutes(app: FastifyInstance): Promise {
  app.get('/health', { logLevel: 'silent' }, async (_req, reply) => {
    const checks: HealthStatus['checks'] = {}

    // Check PostgreSQL
    const pgStart = Date.now()
    try {
      await prisma.$queryRaw`SELECT 1`
      checks.postgres = { status: 'ok', latencyMs: Date.now() - pgStart }
    } catch (err) {
      checks.postgres = { status: 'fail', latencyMs: Date.now() - pgStart, error: String(err) }
    }

    // Check Redis
    const redisStart = Date.now()
    try {
      await redis.ping()
      checks.redis = { status: 'ok', latencyMs: Date.now() - redisStart }
    } catch (err) {
      checks.redis = { status: 'fail', latencyMs: Date.now() - redisStart, error: String(err) }
    }

    const allOk = Object.values(checks).every((c) => c.status === 'ok')
    const anyFail = Object.values(checks).some((c) => c.status === 'fail')

    const status: HealthStatus['status'] = allOk ? 'ok' : anyFail ? 'degraded' : 'down'
    const httpStatus = status === 'ok' ? 200 : status === 'degraded' ? 200 : 503

    return reply.status(httpStatus).send({
      status,
      checks,
      uptime: process.uptime(),
      timestamp: new Date().toISOString(),
    })
  })
}

Backup Script for PostgreSQL Volume

#!/bin/bash
# scripts/backup-postgres.sh
set -euo pipefail

BACKUP_DIR="/backups/postgres"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="${BACKUP_DIR}/dump_${DATE}.sql.gz"
RETENTION_DAYS=7

mkdir -p "${BACKUP_DIR}"

echo "[$(date)] Starting PostgreSQL backup..."

docker exec myapp-postgres-1   pg_dump -U "${POSTGRES_USER:-myapp}" "${POSTGRES_DB:-myapp}" |   gzip > "${BACKUP_FILE}"

echo "[$(date)] Backup written to ${BACKUP_FILE} ($(du -sh "${BACKUP_FILE}" | cut -f1))"

# Delete backups older than retention period
find "${BACKUP_DIR}" -name "dump_*.sql.gz" -mtime +"${RETENTION_DAYS}" -delete
echo "[$(date)] Cleaned backups older than ${RETENTION_DAYS} days"

Ready-to-use Docker Compose templates, Node.js starter kits, and production boilerplates are available at WOWHOW developer tools. Browse infrastructure and DevOps resources at the full catalog.

Originally published at wowhow.cloud

FastAPI Production Best Practices: Build Bulletproof Python APIs (2026)

Anup Karanjkar — Thu, 30 Jul 2026 13:16:43 +0000

FastAPI is deceptively easy to start with and surprisingly hard to harden for production. The gap between a working prototype and a bulletproof API shows up in incident post-mortems: unhandled edge cases in Pydantic models, missing request ID propagation, background tasks that silently eat exceptions, and test suites that cover happy paths but nothing else.

This guide covers the patterns that separate production FastAPI deployments from fragile ones. Every code block here is pulled from real service architectures running at scale in 2026. No toy examples.

Try it yourself: Free Curl-to-Code Converter — free, no signup, runs in your browser.

Project Structure That Scales

Before any code, structure matters. A flat main.py works for demos. For production, you need clear separation between routing, business logic, data access, and infrastructure concerns.

myapi/
  app/
    api/
      v1/
        endpoints/
          users.py
          products.py
          health.py
        router.py
    core/
      config.py
      security.py
      logging.py
    db/
      session.py
      base.py
    models/
      user.py
      product.py
    schemas/
      user.py
      product.py
      common.py
    services/
      user_service.py
      product_service.py
    middleware/
      request_id.py
      timing.py
    tests/
      conftest.py
      test_users.py
      test_products.py
  main.py
  Dockerfile
  requirements.txt

Pydantic v2 Models: Validation Done Right

Pydantic v2 is 5-50x faster than v1 and ships with FastAPI 0.100+. The API changed — validator is replaced by field_validator, and model config uses model_config instead of inner Config class.

# app/schemas/user.py
from __future__ import annotations

from datetime import datetime
from typing import Annotated
from uuid import UUID, uuid4

from pydantic import BaseModel, EmailStr, Field, field_validator, model_validator
from pydantic import ConfigDict

class UserBase(BaseModel):
    model_config = ConfigDict(
        str_strip_whitespace=True,
        str_min_length=1,
        validate_assignment=True,
        populate_by_name=True,
    )

    email: EmailStr
    full_name: Annotated[str, Field(min_length=2, max_length=100)]
    role: Annotated[str, Field(default="user", pattern=r"^(user|admin|moderator)$")]

class UserCreate(UserBase):
    password: Annotated[str, Field(min_length=8, max_length=72)]
    password_confirm: str

    @field_validator("password")
    @classmethod
    def password_strength(cls, v: str) -> str:
        if not any(c.isupper() for c in v):
            raise ValueError("Password must contain at least one uppercase letter")
        if not any(c.isdigit() for c in v):
            raise ValueError("Password must contain at least one digit")
        if not any(c in "!@#$%^&*()" for c in v):
            raise ValueError("Password must contain at least one special character")
        return v

    @model_validator(mode="after")
    def passwords_match(self) -> "UserCreate":
        if self.password != self.password_confirm:
            raise ValueError("Passwords do not match")
        return self

class UserRead(UserBase):
    id: UUID = Field(default_factory=uuid4)
    created_at: datetime
    updated_at: datetime
    is_active: bool = True

    model_config = ConfigDict(from_attributes=True)

class UserUpdate(BaseModel):
    model_config = ConfigDict(str_strip_whitespace=True)

    full_name: Annotated[str, Field(min_length=2, max_length=100)] | None = None
    email: EmailStr | None = None

    # Ensure at least one field is provided
    @model_validator(mode="after")
    def at_least_one_field(self) -> "UserUpdate":
        if self.full_name is None and self.email is None:
            raise ValueError("At least one field must be provided for update")
        return self

Dependency Injection: The Right Way

FastAPI's dependency injection is its most powerful feature and most commonly misused. Dependencies should be composable, testable, and cover cross-cutting concerns like auth, database sessions, and rate limiting.

# app/core/dependencies.py
from typing import Annotated, AsyncGenerator
from uuid import UUID

from fastapi import Depends, Header, HTTPException, Request, status
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
from jose import JWTError, jwt
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.config import settings
from app.db.session import AsyncSessionLocal
from app.models.user import User
from app.services.user_service import UserService

# --- Database session dependency (async, scoped per request) ---

async def get_db() -> AsyncGenerator[AsyncSession, None]:
    async with AsyncSessionLocal() as session:
        try:
            yield session
            await session.commit()
        except Exception:
            await session.rollback()
            raise
        finally:
            await session.close()

DBSession = Annotated[AsyncSession, Depends(get_db)]

# --- JWT auth dependency ---

security = HTTPBearer(auto_error=False)

async def get_current_user(
    db: DBSession,
    credentials: HTTPAuthorizationCredentials | None = Depends(security),
) -> User:
    if credentials is None:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="No authentication credentials provided",
            headers={"WWW-Authenticate": "Bearer"},
        )
    try:
        payload = jwt.decode(
            credentials.credentials,
            settings.SECRET_KEY,
            algorithms=[settings.ALGORITHM],
        )
        user_id: str | None = payload.get("sub")
        if user_id is None:
            raise HTTPException(status_code=401, detail="Invalid token payload")
    except JWTError:
        raise HTTPException(status_code=401, detail="Invalid or expired token")

    user_service = UserService(db)
    user = await user_service.get_by_id(UUID(user_id))
    if user is None or not user.is_active:
        raise HTTPException(status_code=401, detail="User not found or inactive")
    return user

CurrentUser = Annotated[User, Depends(get_current_user)]

# --- Role-based access control (composable with CurrentUser) ---

def require_role(*roles: str):
    async def check_role(current_user: CurrentUser) -> User:
        if current_user.role not in roles:
            raise HTTPException(
                status_code=status.HTTP_403_FORBIDDEN,
                detail=f"Role '{current_user.role}' is not authorized for this action",
            )
        return current_user
    return check_role

AdminUser = Annotated[User, Depends(require_role("admin"))]

# --- Pagination dependency ---

class PaginationParams:
    def __init__(
        self,
        page: Annotated[int, Query(ge=1, default=1)],
        page_size: Annotated[int, Query(ge=1, le=100, default=20)],
    ):
        self.offset = (page - 1) * page_size
        self.limit = page_size
        self.page = page
        self.page_size = page_size

Pagination = Annotated[PaginationParams, Depends(PaginationParams)]

Structured Error Handling

FastAPI's default error responses are inconsistent — validation errors use one shape, HTTP exceptions use another. Production APIs need a uniform error envelope that API clients can reliably parse.

# app/core/error_handlers.py
import logging
import traceback
from typing import Any
from uuid import uuid4

from fastapi import FastAPI, Request, status
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from pydantic import ValidationError
from sqlalchemy.exc import IntegrityError

logger = logging.getLogger(__name__)

class APIError(Exception):
    """Base class for all API errors."""

    def __init__(
        self,
        message: str,
        status_code: int = 400,
        error_code: str = "API_ERROR",
        details: dict[str, Any] | None = None,
    ):
        self.message = message
        self.status_code = status_code
        self.error_code = error_code
        self.details = details or {}
        super().__init__(message)

class NotFoundError(APIError):
    def __init__(self, resource: str, resource_id: Any):
        super().__init__(
            message=f"{resource} with id '{resource_id}' not found",
            status_code=404,
            error_code="NOT_FOUND",
            details={"resource": resource, "id": str(resource_id)},
        )

class ConflictError(APIError):
    def __init__(self, message: str):
        super().__init__(message=message, status_code=409, error_code="CONFLICT")

def error_response(
    request: Request,
    status_code: int,
    error_code: str,
    message: str,
    details: dict | None = None,
) -> JSONResponse:
    return JSONResponse(
        status_code=status_code,
        content={
            "error": {
                "code": error_code,
                "message": message,
                "details": details or {},
                "request_id": getattr(request.state, "request_id", str(uuid4())),
                "path": str(request.url.path),
            }
        },
    )

def register_error_handlers(app: FastAPI) -> None:
    @app.exception_handler(APIError)
    async def api_error_handler(request: Request, exc: APIError) -> JSONResponse:
        return error_response(request, exc.status_code, exc.error_code, exc.message, exc.details)

    @app.exception_handler(RequestValidationError)
    async def validation_error_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
        field_errors = {}
        for error in exc.errors():
            field = ".".join(str(loc) for loc in error["loc"] if loc != "body")
            field_errors[field] = error["msg"]
        return error_response(
            request, 422, "VALIDATION_ERROR", "Request validation failed", {"fields": field_errors}
        )

    @app.exception_handler(IntegrityError)
    async def integrity_error_handler(request: Request, exc: IntegrityError) -> JSONResponse:
        logger.warning("DB integrity error: %s", exc, extra={"request_id": getattr(request.state, "request_id", "")})
        return error_response(request, 409, "CONFLICT", "Resource already exists")

    @app.exception_handler(Exception)
    async def unhandled_exception_handler(request: Request, exc: Exception) -> JSONResponse:
        request_id = getattr(request.state, "request_id", str(uuid4()))
        logger.error(
            "Unhandled exception",
            exc_info=True,
            extra={"request_id": request_id, "path": str(request.url.path)},
        )
        return error_response(
            request, 500, "INTERNAL_ERROR",
            "An unexpected error occurred",
            {"request_id": request_id},
        )

Middleware: Request ID + Timing

# app/middleware/request_id.py
import time
from uuid import uuid4

from starlette.middleware.base import BaseHTTPMiddleware
from starlette.requests import Request
from starlette.responses import Response

class RequestIDMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next) -> Response:
        request_id = request.headers.get("X-Request-ID", str(uuid4()))
        request.state.request_id = request_id
        start_time = time.perf_counter()

        response = await call_next(request)

        duration_ms = (time.perf_counter() - start_time) * 1000
        response.headers["X-Request-ID"] = request_id
        response.headers["X-Response-Time"] = f"{duration_ms:.2f}ms"
        return response

# app/main.py
from contextlib import asynccontextmanager

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from fastapi.middleware.gzip import GZipMiddleware

from app.api.v1.router import api_router
from app.core.error_handlers import register_error_handlers
from app.core.logging import configure_logging
from app.middleware.request_id import RequestIDMiddleware

@asynccontextmanager
async def lifespan(app: FastAPI):
    configure_logging()
    # Startup: initialize connection pools, warm caches
    yield
    # Shutdown: close connections gracefully

def create_app() -> FastAPI:
    app = FastAPI(
        title="My Production API",
        version="1.0.0",
        docs_url="/docs" if settings.ENVIRONMENT != "production" else None,
        redoc_url=None,
        lifespan=lifespan,
    )

    app.add_middleware(RequestIDMiddleware)
    app.add_middleware(GZipMiddleware, minimum_size=1000)
    app.add_middleware(
        CORSMiddleware,
        allow_origins=settings.ALLOWED_ORIGINS,
        allow_credentials=True,
        allow_methods=["*"],
        allow_headers=["*"],
    )

    register_error_handlers(app)
    app.include_router(api_router, prefix="/api/v1")

    return app

app = create_app()

Background Tasks With Error Handling

FastAPI's built-in BackgroundTasks runs tasks in the same process after the response is sent. For anything CPU-heavy or long-running, use Celery or ARQ instead. For lightweight post-response work (sending emails, logging, cache invalidation), BackgroundTasks is fine — but you must handle exceptions or they silently disappear.

# app/services/background.py
import logging
from typing import Callable, Any
from functools import wraps

logger = logging.getLogger(__name__)

def background_task(func: Callable) -> Callable:
    """Decorator that wraps background tasks with exception logging."""
    @wraps(func)
    async def wrapper(*args: Any, **kwargs: Any) -> None:
        try:
            await func(*args, **kwargs)
        except Exception:
            logger.exception(
                "Background task failed: %s",
                func.__name__,
                extra={"args": str(args)[:200], "kwargs": str(kwargs)[:200]},
            )
    return wrapper

# Usage in an endpoint:
# app/api/v1/endpoints/users.py
from fastapi import APIRouter, BackgroundTasks, status

from app.core.dependencies import DBSession
from app.schemas.user import UserCreate, UserRead
from app.services.background import background_task
from app.services.email_service import send_welcome_email
from app.services.user_service import UserService

router = APIRouter(prefix="/users", tags=["users"])

@background_task
async def send_welcome_email_task(user_id: str, email: str, full_name: str) -> None:
    await send_welcome_email(user_id=user_id, email=email, full_name=full_name)

@router.post("/", response_model=UserRead, status_code=status.HTTP_201_CREATED)
async def create_user(
    payload: UserCreate,
    background_tasks: BackgroundTasks,
    db: DBSession,
) -> UserRead:
    service = UserService(db)
    user = await service.create(payload)
    background_tasks.add_task(
        send_welcome_email_task,
        user_id=str(user.id),
        email=user.email,
        full_name=user.full_name,
    )
    return user

Testing: Async pytest With Real Dependencies

# tests/conftest.py
import asyncio
from typing import AsyncGenerator
from uuid import uuid4

import pytest
import pytest_asyncio
from httpx import ASGITransport, AsyncClient
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
from sqlalchemy.orm import sessionmaker

from app.core.dependencies import get_db
from app.db.base import Base
from app.main import app

TEST_DATABASE_URL = "sqlite+aiosqlite:///:memory:"

engine = create_async_engine(TEST_DATABASE_URL, echo=False)
TestSessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)

@pytest_asyncio.fixture(scope="session")
async def setup_db():
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)
    yield
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.drop_all)

@pytest_asyncio.fixture
async def db_session(setup_db) -> AsyncGenerator[AsyncSession, None]:
    async with TestSessionLocal() as session:
        yield session
        await session.rollback()

@pytest_asyncio.fixture
async def client(db_session: AsyncSession) -> AsyncGenerator[AsyncClient, None]:
    async def override_get_db():
        yield db_session

    app.dependency_overrides[get_db] = override_get_db
    async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as ac:
        yield ac
    app.dependency_overrides.clear()

# tests/test_users.py
import pytest
from httpx import AsyncClient

@pytest.mark.asyncio
async def test_create_user_success(client: AsyncClient):
    response = await client.post("/api/v1/users/", json={
        "email": "test@example.com",
        "full_name": "Test User",
        "password": "Secure@123",
        "password_confirm": "Secure@123",
    })
    assert response.status_code == 201
    data = response.json()
    assert data["email"] == "test@example.com"
    assert "id" in data
    assert "password" not in data  # Never leak passwords

@pytest.mark.asyncio
async def test_create_user_weak_password(client: AsyncClient):
    response = await client.post("/api/v1/users/", json={
        "email": "test2@example.com",
        "full_name": "Test User",
        "password": "weakpassword",
        "password_confirm": "weakpassword",
    })
    assert response.status_code == 422
    error = response.json()["error"]
    assert error["code"] == "VALIDATION_ERROR"

@pytest.mark.asyncio
async def test_create_user_duplicate_email(client: AsyncClient):
    payload = {
        "email": "dup@example.com",
        "full_name": "Dup User",
        "password": "Strong@123",
        "password_confirm": "Strong@123",
    }
    await client.post("/api/v1/users/", json=payload)
    response = await client.post("/api/v1/users/", json=payload)
    assert response.status_code == 409

For production-ready developer tools, templates, and starter kits including FastAPI boilerplates, see WOWHOW developer tools. To explore all Python and backend resources, browse the full catalog.

Originally published at wowhow.cloud

DEV Community: Anup Karanjkar

Freelancer Tax Guide India ITR Filing, GST & Tax

What Is undefined?

How to Use undefined

Key Features and Benefits

Common Mistakes to Avoid

People Also Ask

What is the best undefined tool?

Is undefined free?

How do I get started with undefined?

Start with our free tool, then explore the comprehensive templates in the WOWHOW product catalog.

Freelancer Accounting in India: GST, ITR & Bookkeeping

What Is undefined?

How to Use undefined

Key Features and Benefits

Common Mistakes to Avoid

People Also Ask

What is the best undefined tool?

Is undefined free?

How do I get started with undefined?

Start with our free tool, then explore the comprehensive templates in the WOWHOW product catalog.

Gauntlet Loop Reality Check — Costs Nobody Quotes (2026)

What the Gauntlet Loop actually is

The evidence nobody quotes

Why the method survives its own hype

The braked version that works

Should you run one?

Sources

7. How to Run a Gauntlet Loop — Matt Shumer, somethingbig.ai (Jul 2026)

Claude Code Cheat Sheet (2026) — Commands & Shortcuts

Slash commands — the daily drivers

Slash commands — review, workflow, and power tools

CLI commands

CLI flags worth knowing

Keyboard shortcuts

The three that change how a session feels

Keep this handy

Every Claude Code product mentioned is available at wowhow.cloud — pay once, ship forever.

Best AI Prompt Marketplaces in India (2026) — Compared

The comparison at a glance

PromptBase — the dedicated prompt store

Gumroad — creator storefronts, not a catalog

Etsy — prompts sold like craft downloads

PromptHero — discovery first, buying second

WOWHOW — priced in ₹, paid over UPI, bought as packs

What actually matters for an India buyer

Judge a prompt before you pay for it

The verdict

Every prompt pack mentioned from WOWHOW is available at wowhow.cloud — priced in ₹, paid over UPI, pay once and keep it.

Z.ai launches ZCode to challenge Cursor, Claude Code and GitHub Copilot in AI coding | VentureBeat

What Is undefined?

How to Use undefined

Key Features and Benefits

Common Mistakes to Avoid

People Also Ask

What is the best undefined tool?

Is undefined free?

How do I get started with undefined?

Start with our free tool, then explore the comprehensive templates in the WOWHOW product catalog.

Income Tax Calculator India 2025-26: Complete Guide

What Is income tax calculator?

How to Use income tax calculator

Key Features and Benefits

Common Mistakes to Avoid

People Also Ask

What is the best income tax calculator tool?

Is income tax calculator free?

How do I get started with income tax calculator?

Start with our free tool, then explore the comprehensive templates in the WOWHOW product catalog.

Bash Scripting for DevOps: 20 Scripts That Automate Everything

Bash Scripting Fundamentals You Can't Skip

Script 1: Service Health Check

Script 2: Log Rotation and Compression

Script 3: Automated PostgreSQL Backup

Script 4: Zero-Downtime Deploy with Rollback

Script 5: Disk Space Monitoring with Alerts

Script 6: Redis Memory Check and Eviction Policy Monitor

Script 7: Cron Job Wrapper with Logging and Lock

Cron Patterns That Actually Work

Script 8: Environment Variable Validation at Startup