The journey

Every portfolio has an origin story. Mine starts with markets.

I wanted to understand how stocks move — not from theory, but from data. So I built the tools myself. A stock screener that scanned US and Indian markets for signals. A backtesting framework that simulated realistic conditions — slippage, transaction costs, position sizing, drawdown limits. Real backtests, not toy ones.

Then came prediction. swing_ml was an attempt to machine-learn Nifty 500 movement patterns. classify-stock-growth-for-trading was a pipeline that classified stocks by growth trajectory — ETL, ML models, web frontend, all in Docker. I built a Zerodha algo-trading setup for the Indian markets. Quantitative finance, one project at a time.

The output was scrappy but earnest. Python scripts scraping Yahoo Finance, CSV exports, terminal dashboards. The discipline I was building would carry me through everything else.

Trading algorithms led to academic papers. Which led to the gap between a PDF on arXiv and working code. So I built Paper2Code — a pipeline that takes a research paper and uses LLMs to extract methodology and implement it. It processed papers on financial transformers, market microstructure.

That was my first real encounter with LLMs as engineering tools. Not chatbots. Code generators I could direct. The idea stuck.

Around the same time: SSSP (shortest-path algorithms), benchmarked across city datasets. A matching engine — ad network, API, middleware, blacklist management. Spreading across domains, circling the same question: how do I make something that works without a server?

I realised I was working on two things at once. Both needed to exist.

I fine-tuned LoRA adapters on Qwen 2.5 3B for citation-grounded Q&A over Nehru's 159-volume corpus — 79,160 chunks, FAISS, FastAPI, a 14-page discovery site. Then I replicated the architecture for Gandhi, Rajiv Gandhi, Indira Gandhi. Each one: corpus extraction, embedding, SFT fine-tuning, retrieval-augmented generation, bail-out examples to prevent hallucination, a complete discovery site. The nehru project alone taught me more about RAG, LoRA, and production ML than any course.

I built dflash-mlx — block-diffusion speculative decoding on Apple Silicon. For Qwen3.5-4B target with a ~1B draft model: 4.1× speedup over baseline autoregressive decoding. Lossless. Every emitted token verified against the target.

This is where everything changed.

I'd been annoyed for years by the same pattern. Every useful tool requires an account, a server, an API key, a subscription. So I started building the opposite. Tools that live in a single HTML file. No server. No build step. No data leaving the device.

The first ones were small. DotSpin — 15 dot-matrix CSS spinners, zero JavaScript. BabelLocal — 200-language translation in the browser via NLLB and Transformers.js. StripLocal — drag-and-drop EXIF stripping. GambitLocal — chess against Stockfish in a tab.

But they grew. Fast.

Bahi — a Tally/Zoho Books alternative for Indian SMBs. ~18,460 lines of HTML/CSS/JS. Double-entry accounting with SHA-256 hash-chained audit logs, ECDSA P-256 signatures, full GST compliance (GSTR-1, GSTR-3B, CMP-08), inventory with WAC and FIFO, multi-company, PDF invoices with Devanagari, crash recovery via OPFS staging, period locks, financial-year rollover. In a single HTML file. This was where I learned that the Tally bug I was trying to prevent — reprinting a 6-month-old invoice after editing a customer master, seeing the wrong name — is an architectural problem, not a UI one. The snapshot pattern I invented for it (freeze every reference at posting time) is now the backbone of the whole app. Bahi was the proof that a browser tab could replace a desktop accounting package.

Mehfil — E2E encrypted team chat in a single HTML file. ~9,500 lines. Ed25519 + AES-256-GCM + X25519. WebRTC P2P. MessagePack codec written from scratch. QR-based invite. Visual hash fingerprint verification. Local-first, event-sourced replay. No accounts, no server. The hardest decision wasn't engineering — it was choosing not to bolt Mehfil onto the Private Mesh fabric. Documenting that decision, with the criteria that failed, mattered as much as the code.

Tijori — browser-native password vault. AES-256-GCM, Argon2id KDF, WebAuthn PRF hardware-key support. Multi-device sync via any transport — Git, Syncthing, USB, QR flash. Audit hygiene checks. Keepass/CSV import-export.

Kabootar — browser-native file transfer. WebRTC P2P. 14KB chunked framing with SHA-256 verification. Backpressure via bufferedAmount watermark. Tier-A showSaveFilePicker streaming writes. 12–21 MB/s in-tab loopback. SHA-256 verified up to 100 MB.

Lunar — menstrual cycle tracker. Encrypted at rest. Two-slot IndexedDB layout for plausible deniability. Bayesian cycle prediction. Apple Health XML / Flo JSON / Clue CSV import. Zero analytics. Zero network.

There are 25+ of these apps now. They share a pattern library, a design system, a WebGPU inference stack, a worker protocol, a same-origin mirroring strategy. They have a launcher — naklios.dev. They have a fabric — the Private Mesh — for store-and-forward, LAN sync, device pairing when persistent identity makes sense.

And they have a portfolio: naklitechie.github.io.

Somewhere in this stretch I started signing things as NakliTechie. Nakli means fake. The framing is half self-deprecating and half a flag: you don't need to be a "real" engineer to build real things. The full version is in the manifesto.

The browser-native tools proved a single HTML file could do astonishing things. But some patterns repeat across apps. Identity. Storage. Relay. Sync.

So I started building the Private Mesh — primitives that apps can opt into.

Vault — store-and-forward. Durable (SQLite + filesystem on nakli-hub, R2 + KV on nakli-cf-worker) or ephemeral (bounded RAM ring buffer for LAN).

Bridge — LAN discovery and WebRTC signalling via mDNS. Thin, stateless, no protocol processing.

Identity — FIF + passphrase. Cross-tool. Delegable with caveats.

crate-agent — a Go daemon for mesh operations.

The fabric has a 5-point fitness checklist. Apps either fit or they don't. Mehfil doesn't — documented, accepted, architectural siblings. The fabric is infrastructure, not colonialism.

While the browser tools grew, I kept building citation-grounded Q&A systems. nehru was the flagship: 159 public-domain sources, 79,160 indexed chunks, a LoRA-fine-tuned Qwen 2.5 3B that cites or declines, a 14-page discovery site with correspondent bubbles, a timeline scrubber, word-synced audio transcripts, topic clusters, a place map, an EPUB reader. The constitution was explicit: every answer must cite. If none is found, the model says so. No fabrication.

The same architecture was replicated for Gandhi, Rajiv Gandhi, Indira Gandhi — each with its own corpus, LoRA adapter, site. Perhaps the most meaningful work in the portfolio. Making the written and spoken record of India's foundational leaders accessible, queryable, verifiable.

Stance was a sibling thread: a hosted platform for timestamped public stands on issues. SHA-256 hash chain. Revision history. Daily Bitcoin-anchored integrity checks. Users can verify the chain independently with a Python script. A cryptographic notary for opinions, built on PocketBase.

The Model Context Protocol arrived — a standard for AI tools to interact with the world. I built fetch-mcp, an MCP server that fetches web content as HTML, JSON, plain text, or Markdown. Simple, focused.

I worked on free-code — a fork of Claude Code with telemetry stripped, security prompt guardrails removed, all 45+ experimental features unlocked. And clicky — an open-source macOS AI companion with voice, screen capture, Claude-powered cursor pointing (SwiftUI, Cloudflare Worker proxy, AssemblyAI streaming transcription, ElevenLabs TTS).

The throughline. I want AI tools to be mine. Auditable, forkable, running where I want them to run.

Two projects that don't fit any theme but are pure joy.

ingenious-machines — all 4 volumes of the classic engineering treatise brought to life with animated SVG. 49 mechanisms in Volume 1 alone: cams, ratchets, tripping mechanisms, reversing drives, differential motions, Geneva stops. An OCR pipeline extracted text and bounding boxes from scans. I rendered the mechanisms as hand-coded SVG with requestAnimationFrame animation. Zero dependencies. A browser tab is now a mechanical engineering reference.

mechanikon — a digital museum of historical systems of understanding. The Antikythera mechanism with three switchable gear-train reconstructions (Freeth 2006, Freeth 2021, Wright 2012). Calendars of the World — 26 systems across three visualisation views, a mathematical port of Reingold & Dershowitz's Calendrical Calculations. Both browser-native, static, MIT licensed.

Some work is about extraction. The research repo collects Indian economic and social statistics from public sources — wages and milk prices (2015–2024), the RBI Handbook of Statistics (17 editions, 2008–2025), retail prices. Databases, schemas, extractors, cross-edition validation pipelines all in the repo. The data wants to be free.

SansadSaar took the same ethos into Indian democracy — a browser-native reader for Parliamentary Committee reports. 24 DRSCs, 2,671 reports, full-text search, AI summaries (local Gemma on WebGPU, or BYOK for Anthropic/OpenAI/Gemini). When I discovered the source API didn't support CORS, the right answer wasn't a proxy. It was a static mirror sidecar with a daily GitHub Action.

The work isn't finished. These are the threads I'm still pulling.

The Private Mesh fabric is being woven into more apps. The Stance platform needs deployment. IndiaVotes election data wants a browser-native reader. The Mac app infrastructure — Stash, clicky — is growing. qissa, a story-to-video pipeline for Indian literature, is in active development.

And there are always new ideas in IDEAS.md — a queue of browser-native tools waiting to be built.