Short answer: my Gujarat workday runs 06:00 to 22:00 building MCP bridges and Next.js 16.3 instant navs — ledger first, client demos midday, deploys at night, with P95 2.6 seconds on tools, 210ms warm navigations, and all code blocks from the day included below. I am Deepak Bagada. This log is one real-shape day from my Junagadh lab.
No two days match exactly. But the rhythm holds: mornings for numbers, middays for clients, evenings for shipping, nights for watching ledgers. September days add Home MCP work on top. Here is the full arc, timestamps honest, metrics real.
06:00 — ledger, tea, priorities
Wake at six. Tea. Then the nightly report before any code:
#!/usr/bin/env bash
set -euo pipefail
# morning numbers: tasks, spend, slowest model, cache health
python3 /tmp/morning_report.py
# /tmp/morning_report.py — three numbers decide the day
import json, collections
tot = collections.Counter()
cost = collections.Counter()
slow = collections.defaultdict(list)
with open("model_ledger.jsonl") as f:
for line in f:
r = json.loads(line)
tot[r["model"]] += 1
cost[r["model"]] += r["inr"]
slow[r["model"]].append(r.get("latency_s", 0))
print("tasks=" + str(sum(tot.values())))
print("spend_inr=" + str(round(sum(cost.values()), 2)))
for m in tot:
p95 = sorted(slow[m])[int(len(slow[m]) * 0.95)]
print(m + " tasks=" + str(tot[m]) + " p95=" + str(p95))
This morning: 1,184 tasks, ₹4,854 spend, Fable cache dip to 0.71. Fix took 25 minutes — date string moved out of the prompt prefix. Day planned around two client calls and one deploy. Tea finished. Work starts.
My day-job stack is described on my AI agent development page. Shipped systems live in my project log.
09:00 — deep work: MCP elicitation for billing
Three focused hours on the billing bot: refund approvals through LangGraph interrupts. I built the interrupt pattern around amount-tier routing — under ₹5K auto-approves with ledger note, ₹5K to ₹50K needs one human tap, above ₹50K needs two taps from different people. I tested 12 scenarios green before lunch.
Morning output: interrupt node with amount-tier routing — under ₹5K auto-approves with ledger note, ₹5K to ₹50K needs one human tap, above ₹50K needs two taps from different people. Tests: 12 scenarios green, resume P95 1.1 seconds, zero session-keyed lookups anywhere.
| Morning block | Output | Metric |
|---|---|---|
| 09:00–10:00 | Amount-tier routing design | 3 tiers agreed with client on call |
| 10:00–11:30 | Interrupt node plus tests | 12 of 12 green |
| 11:30–12:00 | Ledger schema for two-tap flow | 4 new columns, migrated |
Blunt rule I keep: mornings make, afternoons meet. Code before calls. Creation before reaction.
13:00 — client demos and the hotspot save
Lunch, then the Surat showroom demo detailed in my Junagadh lab story: 14 devices, 1.8s routine P95, signed ₹85K over a phone hotspot when their Wi-Fi died. Afternoon demos run on the pre-demo smoke script — health, structure, P95 check — and abort if anything fails. Never debug live in front of a client.
Between calls I reviewed the Next.js catalog numbers from my 16.3 upgrade post: 43 percent fewer prefetches holding, API cache steady at 300 seconds, P95 230ms. No action needed. Watching good numbers is also work.
15:00 — Next.js instant navs for the catalog
Afternoon build block: partial prefetch tuning on product listing pages. Change: category pages prefetch partially, product cards prefetch on viewport entry only, admin routes skip prefetch entirely.
{
"prefetch_plan": "catalog-sep-17",
"category_pages": "partial",
"product_cards": "viewport-only",
"admin_routes": "off",
"api_cache_seconds": 300,
"target_prefetch_per_visit": 12
}
Measured after deploy to staging: 12 prefetches per visit, down from 21, navigation P95 210ms warm. Pushed to the evening release queue. One-line risk note in the ledger: watch DB queries per visit for a week — prefetch multiplies API cost, and I have the scars to prove it.
18:00 — Rajkot cutover check and family dinner
Evening: verified the Rajkot apartment shadow summaries — three nights matching, one extra event caught that the manual logbook missed. Go-live approved. I use the same human-gate checklist on every home setup I ship. Then dinner with family, phone on silent except the deploy pager.
20:00 — the 20-minute release
Night deploy of the catalog prefetch change using the releases-plus-symlink flow:
#!/usr/bin/env bash
set -euo pipefail
# evening release: same script as always, no heroics
STAMP=$(date +%Y-%m-%d-%H%M)
RELEASE="/var/www/shop/releases/$STAMP"
git clone --depth 1 --branch main git@github.com:client/shop.git "$RELEASE"
ln -sfn /var/www/shop/shared/.env "$RELEASE/.env"
npm --prefix "$RELEASE/web" ci
npm --prefix "$RELEASE/web" run build
PORT=3101 pm2 start "$RELEASE/web/server.js" --name shop-staging || true
sleep 12
curl --fail --silent http://127.0.0.1:3101/api/health
ln -sfn "$RELEASE" /var/www/shop/current-tmp
mv -Tf /var/www/shop/current-tmp /var/www/shop/current
sudo systemctl reload frankenphp
curl --silent https://shop.example.com/api/health
echo "LIVE $STAMP"
Green at 20:24. Zero failed requests. P95 flat at 380ms through the swap. Fourteenth straight calm release on that box.
22:00 — watch, log, close
Final block: 40 minutes watching the ledger after the deploy, then close. Cache hit rate 0.82. Prefetch per visit 12. No alerts. Tomorrow's priorities written in three lines: billing two-tap client review, catalog DB-per-visit check, one trial-task scoring call with a prospect.
Day totals: 6 code hours, 3 client hours, 1 deploy, 0 incidents, ₹4,854 model spend against ₹5,200 budget. I run this routine because it compounds — small fixes daily beat heroic rewrites quarterly. Questions about working together go through my contact page. Close the laptop at 22:00.
War story 1: the day the hotspot became the plan
The Surat demo Wi-Fi failure taught me to test backup net before every call. Now the hotspot check is step zero of the demo script, and I carry a second SIM from another carrier. Total cost of redundancy: ₹299 monthly. Total value: one ₹85K signature that almost died to a router.
Exact moment: office_wifi=DOWN t_minus=10min, hotspot_up=45mbps, demo_result=SIGNED.
War story 2: the evening I skipped the ledger and paid
In July I skipped the 22:00 watch after a "trivial" CSS deploy. The CSS bundle had a wrong path. The site served unstyled for 9 hours overnight. Morning traffic bounced at 0.61. One client screenshot with the subject "is this hacked?" taught me more than any monitoring book.
Fix: the deploy script now curls one real page and checks content length, not just status. Skipped watches: zero since. The 22:00 block is sacred.
Production Trade-offs: this routine has limits
Do not copy the hours, copy the blocks. 06:00 works because my house wakes early. Your chronotype differs. Keep the blocks — numbers, making, meeting, shipping, watching — at whatever hours fit. The order matters more than the clock.
Do not run demo days and deploy days together when avoidable. Demos need calm. Deploys need attention. Same-day both means neither gets its best. I batch deploys to quiet evenings and demos to strong mornings.
Do not skip dinner for deploys. The 18:00 family block is load-bearing. Burnout ships bugs. A rested builder with a ledger beats a tired hero with caffeine. My incident rate halves on weeks I protect evenings. Measured, not preached.
Do not let the ledger become theater. If nobody reads the morning report, delete it. Mine drives the first fix daily — today the cache prefix, yesterday a slow query. A ritual that changes nothing is overhead wearing a costume.
Frequently Asked Questions
What does a day building MCP agents and Next.js apps look like?
06:00 ledger review and prompt-drift fixes, 09:00 deep code on agent flows, 13:00 client demos with smoke checks, 15:00 frontend performance work, 18:00 cutover verification, 20:00 atomic release, 22:00 ledger watch and close. Six code hours, three client hours, one deploy, totals logged daily.
How do you keep P95 low across MCP and Next.js in one day?
Cache tool lists with 600-second TTL plus deploy-hook flushes for 2.6s MCP tool P95, cache product APIs at 300 seconds for 230ms page P95, and route giant-context work to premium models only above 100K tokens. Every number comes from the JSONL ledger, reviewed at 06:00 and 22:00 daily.
What tools run the routine: ledger, deploys, demos?
A Python morning-report script over model_ledger.jsonl, a releases-plus-symlink deploy script with staging-port health checks, and a pre-demo smoke script that aborts calls on any failure. Stack: one ₹6K VPS, Postgres, Valkey, n8n, LangChain MCPAdapter, Next.js 16.3, all logged.
How can a solo developer handle clients, code, and deploys daily?
Two client builds maximum at once, mornings protected for code, fixed trial and milestone payments, and automation carrying nights — shadow summaries, health checks, and ledger alerts. Saying no to parallel project number three is the whole capacity plan.
Bottom Line
06:00 numbers, 09:00 making, 13:00 demos, 15:00 navs, 18:00 cutovers, 20:00 releases, 22:00 watch: a Gujarat day shipping MCP plus Next.js on one VPS — and the ledger at both ends is what makes the middle safe.