I design and build websites, full apps, RAG pipelines and AI automation — with AI deep in my workflow, so one engineer covers what used to need a team. Five years as the last quality gate before release is why it holds up after launch: everything below was built to be proved, not just demoed.
Taking new projects — remote, worldwide. Replies within a day.
Editorial, fast, hand-tuned sites — designed, written and built by the same person, so nothing gets lost between the mockup and the code.
Spec to working product: backend, database, frontend and the tests that keep it honest — one engineer owning the whole stack.
Multi-step work an LLM can do reliably — research, triage, reporting — built as agents with schemas, guardrails and retries, so the output is something you can check.
Assistants that answer from your own documents, cite their sources, and refuse when retrieval is too weak to support an answer.
Make your site legible to ChatGPT, Claude, Perplexity and AI search answers: structured data, crawl rules that admit assistant bots, and pages written to be quoted.
An application security review from someone who has spent five years breaking software before users could — plus readiness reviews against SOC 2, ISO 27001, GDPR and India's DPDP Act, so the formal audit holds no surprises.
Before your AI feature ships, find out whether it actually works: reproducible eval environments, objective verifiers, and failure modes hunted on purpose.
Regression suites that run themselves and stay green for the right reasons — web, mobile and API, wired into CI.
The marketing site for Shway, “Tinder for your plans”. The hero is a swipe deck you can actually drag, flick and match with, followed by scroll-driven storytelling and an autoplay gallery that pauses when you look at it. GSAP with ScrollTrigger, Draggable and SplitText over Lenis smooth scroll, in hand-written HTML, CSS and JavaScript with no build step.
An India-first Splitwise alternative: split the bill, settle in one UPI tap. Django/DRF over PostgreSQL with a framework-free money core held in integer paise, plus an installable React PWA. The correctness layer is proved against spec vectors and Hypothesis property tests before it ever touches a database.
Five CrewAI agents research a listed stock the way a desk would: fundamentals across eight yfinance endpoints, neural news search, technical indicators written from scratch in pandas, and a dynamically chosen peer set — fused into a BUY/HOLD/SELL call with a confidence score and a generated PDF report.
A multi-agent RAG assistant that answers GitLab questions straight from the official documentation — grounded, cited, and thrown away when the retrieved chunks are not good enough to support an answer. CrewAI agents, local ChromaDB retrieval, async smart routing, Streamlit UI, and it runs entirely on free tiers.
A writing standard that makes AI-generated prose read as though a person wrote it — used as a checklist while drafting, or as an editing pass over text that already sounds machine-written. Rules are tiered so structure and stance get fixed before cosmetic tells. Product, copy, brand and front end built end to end by one person.
Fast is only useful if the shape is right. Three of the systems above, drawn out — the boundaries, the data flow, and the decisions that hold them together. Each links to the full case study.
frontend-monzo/ React · Vite · Tailwind · installable PWA
│
│ fetch /api/v1 (JWT bearer, Idempotency-Key)
▼
backend/ Django + DRF — modular monolith
core/ auth · directory · groups · expenses
balances · turn · settlements · AI entry
│
│ calls into, never re-implements
▼
backend/domain/ pure Python — zero Django imports
money.py integer paise, no floats anywhere
split.py largest-remainder allocation
balance.py balances derived from the ledger
simplify.py debt minimisation
turn.py "Turn to Pay" fairness rotation
upi.py upi://pay intent builder
▲
└── tests/test_vectors.py every worked spec example
tests/test_property.py Hypothesis invariants
(both run with no database) CLI · main.py --stock SYRMA.NS
│
startup validation
env vars · symbol format · live API reachability
│
╔══════════════════════▼══════════════════════════════╗
║ PHASE 1 — four crews, ThreadPoolExecutor(4) ║
╚══╤═══════════╤════════════╤════════════╤════════════╝
│ │ │ │
┌────▼────┐ ┌────▼────┐ ┌─────▼─────┐ ┌────▼─────────┐
│Financial│ │ News │ │ Technical │ │ Peers │
│8 yfinance│ │ EXA │ │ RSI MACD │ │ LLM picks │
│tools │ │ neural │ │ BB SMA │ │ 4–5 comps, │
│ │ │ search │ │ volume │ │ no hardcode │
└────┬─────┘ └────┬────┘ └─────┬─────┘ └────┬─────────┘
└────────────┴────────────┴────────────┘
│
╔══════════════════════▼══════════════════════════════╗
║ PHASE 2 — sequential ║
╚══════════════════════╤══════════════════════════════╝
│
analyst · no tools by design
│
fin_expert · InvestmentRecommendation
│ ├─ action: BUY | HOLD | SELL
│ ├─ confidence: 0.0–1.0
│ ├─ target_price, current_price
│ ├─ reasons: ≥ 2
│ └─ risks: ≥ 1
│
guardrail fails ──► CrewAI retries the task
│ with the error as feedback
▼
markdown artifacts + [SYMBOL]_Report.pdfUser query │ ▼ Smart Router ├─ under ~4 words / ambiguous ──► FULL pipeline │ intent classify ─┐ asyncio │ query rewrite ──┘ .gather() └─ clear, 5+ words ──────────────► straight to retrieval │ ▼ Retriever Agent (CrewAI) semantic_search · filtered_search · multi_query_search ChromaDB cosine similarity · RRF fusion │ │ heuristic validation: drop every chunk below 0.40 relevance │ (nothing clears it → no answer, which is the correct outcome) ▼ Synthesiser Agent (CrewAI) writes only from surviving chunks · cites every claim flags deprecated features · never extrapolates │ ▼ Cited answer + source URLs + route pill + response time
AI writes a lot of my first drafts — code, tests, copy. That is what lets one engineer move at the pace of a team. What it does not do is decide when the work is right. That part is five years of test engineering, and it is built into every step.
Before any code: the outcome, the edge cases, and the check that will prove it. On Squared Up that was a written domain spec whose worked examples later became the test suite.
Claude Code is my main engineering tool, set up per project: context engineering in a project memory file that records the architecture and its contracts, custom skills, MCP servers for the browser and outside tools, and sub-agents for parallel research and review. Plan first, then build, then check the result in a real browser. It is how a solo build covers frontend, backend and infrastructure without cutting corners.
Property-based tests on money math, schema guardrails on agent output, relevance floors on retrieval, verifiers checked against a reference solution. AI speeds up the writing; the checks make it safe to ship.
Dockerised, deployed, observable — and honest about scope: what shipped, what is parked, and why. Then the next loop starts from real use instead of guesses.
Correctness used to be binary: run it twice, get the same answer. AI coding agents broke that assumption, and I moved toward the break rather than away from it. I design the evaluation environments that decide whether an agent actually did the job — and the hard part is not the agent, it is making a red run mean exactly one thing.
How I test an agent →