Full-stack engineer who ships products end to end — from a written spec to production on AWS.

I like taking an idea, turning it into a concrete specification, and driving it all the way to real, deployed features. My recent work is AI-heavy: video generation pipelines, real-time interview intelligence, and tooling that makes AI coding agents themselves more reliable. I build spec-first with Claude Code as a pair — most features below went from thought → spec → implementation → automated AWS deployment, with the infra scripts generated and hardened along the way.

Paste a script, get a fully edited video: Gemini segments the script into scenes (duration, emotion, visual search query per scene), stock footage is auto-curated from Pexels with multimodal AI ranking of thumbnails, ElevenLabs generates the voiceover (an "AI audio director" picks the right voice for the mood), and FFmpeg renders the final cut with styled, burned-in subtitles.

What I built

• A full interactive timeline editor in Next.js 15 / React 19 — storyboard with scene split/merge/reorder, instant asset-swap drawer with pre-fetched alternates, per-scene subtitle styling, live preview synced to voiceover audio.
• A pgvector semantic cache for stock assets: search queries are embedded, cache hits return instantly, misses fall back to the Pexels API while a background worker tags and embeds new assets for future reuse.
• A scale-to-zero AWS architecture: Express API on ECS Fargate, an SQS-driven FFmpeg export-worker fleet on Fargate with autoscaling, Lambda for background tagging, S3 + CloudFront for media delivery — designed for $0/month idle cost.
• 20+ deploy/setup/monitoring scripts (ECR push, ECS service deploys, SQS setup, IAM roles, worker autoscaling, log checks) plus GitHub Actions CI/CD using OIDC role assumption — no long-lived AWS keys, separate pipelines for the API and the worker fleet.
• Extras that turned it into a product: voice cloning, an autopilot scheduler for recurring video creation, YouTube publishing, token-based billing, and a suite of free SEO micro-tools (hook/title/script generators) for organic acquisition.

What I learned

• Decoupling heavy compute (FFmpeg renders) from the API via a queue + on-demand Fargate tasks is the difference between a demo and something that survives real load — and keeps idle cost at zero.
• Multimodal LLM ranking (comparing thumbnails against scene emotion/description) beats keyword search alone for asset curation, and a semantic cache makes it fast and cheap on repeat queries.
• Every AI call needs a fallback path — a regex-based offline segmenter keeps the product usable when the LLM API rate-limits or fails.

An AI-powered recruitment platform that bridges ATS and video interviewing: real-time interview rooms on LiveKit, and an audio intelligence pipeline that turns every interview into structured, searchable hiring evidence. 📖 Technical blog →

What I built

• A multi-tenant platform with distinct candidate, recruiter, and admin portals (Next.js App Router), covering the full lifecycle: job board → applications → scheduling → live interview → AI report.
• An asynchronous audio intelligence worker: LiveKit recordings land in S3 → SQS events trigger the worker → FFmpeg normalizes audio chunks → Whisper transcribes with timestamps → transcripts are merged into speaker turns and Q&A spans → an LLM extracts competency evidence and synthesizes a hire/no-hire signal with confidence scores.
• A RAG layer over interviews: transcripts and evidence are embedded and stored in Qdrant, so recruiters can semantically ask things like "did the candidate mention Docker?" even when the exact keyword was never said.
• A lean, fast backend on Hono + Bun with raw SQL over Postgres (no ORM), Redis for caching/session state, and Dockerized services orchestrated with Docker Compose and PM2.

What I learned

• Real-time media is its own discipline: recording chunked audio from live sessions and reconstructing clean, ordered transcripts asynchronously requires careful event design (SQS decoupling saved the API from ever blocking).
• "AI says hire" isn't a product — evidence with confidence weights tied to transcript spans is. Structuring LLM output into verifiable, quotable data points is what makes it trustworthy.
• Choosing boring-but-sharp tools (raw SQL, a minimal router, a queue) keeps a microservices-like system debuggable by one person.

After shipping two products with AI agents, I built tooling to fix their failure modes: drift (building something subtly different from what you asked), false done (claiming completion without proof), and surprise diffs. One command — npx reliable-ai-agents init — installs enforcement skills into whichever coding agent you use.

What I built

• An npm CLI that installs five skills — plan-first, test-first, bugfix, pipeline, changelog — into the native config format of 9+ agents (Claude Code, Cursor, Windsurf, Kiro, Gemini CLI, GitHub Copilot, Codex, OpenCode, Antigravity).
• Idempotent, non-destructive injection: shared files like AGENTS.md are updated via delimited blocks, so existing content and other skills are never clobbered; re-running init is always safe.
• A drop-in skill registry — adding a new skill is just a folder with skill.md + meta.json, no installer code changes; every agent adapter picks it up automatically.
• The tool itself was built test-first (TypeScript, Vitest, tsup, Biome) — the harness that enforces TDD is proven by TDD.

What I learned

• The highest-leverage fix for AI-assisted development isn't a better model, it's process enforcement: approved plans and approved tests as the spec, with a locked red→green loop before "done" is allowed.
• Guardrails should be firm gates, not jails — skips are permitted but stamped visibly (⚠ OVERRIDE), so nothing happens silently.
• Designing one abstraction (a skill) that renders cleanly across nine different agent formats is an exercise in finding the true core of an idea.

• Spec-first, AI-paired: I write product/technical specs, then drive Claude Code from thought to implemented feature — reviewing, testing, and hardening as I go. All three projects above shipped this way.
• Infra as scripts: every project carries its own reproducible deployment — ECS Fargate task definitions, ECR pipelines, SQS/IAM setup scripts, GitHub Actions with OIDC — so shipping to AWS is one command, not an afternoon.
• Async by default: heavy work (rendering, transcription, embedding) always goes behind a queue with an autoscaling worker; the API stays fast and the idle bill stays at zero.

• Frontend: Next.js, React, TypeScript, Tailwind CSS
• Backend: Node.js, Bun, Express, Hono, WebSockets, raw SQL on PostgreSQL
• AI/ML: Gemini, OpenAI (GPT / Whisper / embeddings), ElevenLabs, pgvector, Qdrant, RAG pipelines
• Infra: AWS (ECS Fargate, Lambda, SQS, S3, CloudFront, ECR, IAM), Docker, GitHub Actions (OIDC), PM2, Supabase, Redis, LiveKit, FFmpeg

📫 Reach me at rakeshgandla200@gmail.com · More projects on my GitHub