I ship AIand the apparound it.
I build the whole thing — the model that runs it, the application that serves it, and the interface people actually touch.
Most people do one of these.
Make the model run at all
Open weights are not software. Getting one onto real hardware means picking a quantization, budgeting VRAM against context length, and wrapping the result in something that answers a request without falling over because the GPU is already busy.
Wire it into a real application
The model is one service among several. It still needs routes, a data layer, auth, a queue for the jobs that take a minute, and an honest error state for the day it is down. This is the part that turns a demo into something a business can actually depend on.
Make it worth looking at
Nobody trusts software that looks unfinished. Layout, type scale, motion that explains rather than decorates, and the states nobody remembers to draw — empty, loading, failed. The page you are reading is the argument: every pixel and every scroll on it is mine.
What is actually on the machine.
Not case studies. 5 things I have built or keep running — what it took to make each one start, and where you can go look at it.
Each process reports its own measure — resident VRAM on a 24 GB card for the inference work, Lighthouse and throughput for the full-stack builds. Approximate, and measured here rather than quoted.
SD-Native
AI Integration · 2025 · shippedStable Diffusion as a desktop app, not a browser tab
A native front end over an AUTOMATIC1111 backend — model switching, live preview while a job renders, a job queue, and VRAM-aware defaults so a smaller card degrades instead of falling over. The person using it never opens a terminal.
adankhan.net
Web & UI Design · 2026 · liveThis site — designed, built and deployed end to end
Next.js on the App Router with React 19, two WebGL scenes rendered through React Three Fiber, GSAP ScrollTrigger driving every pinned section, and Lenis smoothing the scroll. Design, build, contact backend, DNS and deploy are all mine. Everything you are currently looking at is the deliverable.
Local LLM Runtime
AI Integration · 2025 · runningOne 4090 behaving like an inference server
Ollama, llama.cpp and LM Studio driving Qwen and DeepSeek builds from one place. GGUF conversion, quantization chosen per model instead of per habit, and layer offload tuned until the weights and the context both fit on the card.
Headless ComfyUI
Full-Stack Development · 2024 · in useNode graphs that run with no browser open
ComfyUI workflows executed as a job rather than a UI session — graphs built programmatically, custom nodes where the stock ones run out, and batches that survive being interrupted and pick up where they stopped.
Integration Rescue
Full-Stack Development · ongoing · openThe job people actually hire me for
Someone has a model, an application, and a wall between them. It is almost always CUDA against the wrong torch build, a checkpoint in a format nothing will load, or memory that fragments an hour into a run. Ongoing client work.
It starts as 30GB of floats
A raw checkpoint is not a product. It is a directory of tensors with no interface, no memory budget and no idea what hardware it is about to meet.
Squeeze it onto the card
GGUF conversion, 4-bit and 8-bit quantization, KV-cache tuning, layer offloading. The difference between 'out of memory' and 60 tokens a second.
Wrap it in something callable
llama.cpp, Ollama or a custom FastAPI server. Streaming responses, batching, warm starts, graceful failure when the GPU is already busy.
Hand it to a human
A web app or a desktop app with a real interface. Progress bars, cancellable jobs, model management. The user never learns what a tensor is — that is the whole point.
9 things people actually hire me for.
Three of these are about making a model run. Three are about the software around it. Three are about whether anyone enjoys using the result. Most projects need at least one from each column.
AI Integration
0301Local LLM deployment
Get open models running fast on your own hardware — llama.cpp, Ollama, vLLM, GGUF quantization, GPU offload tuning.
02Diffusion pipelines
Stable Diffusion and ComfyUI wired into real applications: headless graph execution, custom nodes, batch and queue systems.
03Inference optimization
Profiling and fixing the slow path — CUDA issues, VRAM fragmentation, precision choices, throughput versus latency tradeoffs.
Full-Stack Development
0301Full-stack web applications
Next.js front to back: routing, route handlers, auth, the data layer, and a deploy that goes out when you push. Built to be handed over, not babysat.
02AI features in existing apps
Dropping generation, chat or search into a codebase that already exists — streaming endpoints, job queues, retries, and sane behaviour when the model is down.
03AI desktop applications
Python inference backends packaged behind a native UI, so non-technical users get a double-clickable app instead of a README.
Web & UI Design
0301Interface & design systems
Type scale, spacing, colour and component states defined once and reused, so the tenth screen still looks like the first one.
02Motion & 3D on the web
Scroll-driven storytelling, WebGL scenes and interaction that has a reason to exist — held to a frame budget, not bolted on at the end.
03Performance & accessibility
Real numbers on real devices: layout that holds down to a small phone, keyboard and screen-reader paths that work, and motion that backs off when the OS asks.
An AI feature is only as good as the app around it.
That is the whole reason I work across three layers instead of specialising in one. A model that answers in 400ms is worthless behind a form that loses your input. A beautiful interface is worthless if the inference behind it dies on the second concurrent user. The failures live at the joins.
So I have spent my time in the unglamorous parts of all three: CUDA version conflicts and VRAM fragmentation at the bottom, hydration errors and cache headers in the middle, and at the top the type scale and the empty state — the details that decide whether software feels finished or feels like a prototype.
What that buys you is that there is no handoff. No waiting while the backend team and the frontend team agree whose bug it is. One person owns the path from the weights on disk to the pixel on the screen.