Full-Stack AI Product Engineer (Full-Time Contract Role)

## About the role A note before you apply This is a full-time contract role. We are looking for independent engineers only — please do not apply if you are representing a consultancy, staffing firm, or any kind of agency. We will not engage with third-party vendors or contract houses for this position. If you are a solo engineer, available full time, and looking for serious hands-on work — read on. ## About CellStrat CellStrat is an AI startup with two sides to the business. The services arm builds end-to-end AI engineering solutions for US-based clients across industries — this is the more mature side of the company, running real projects with real deadlines. The product side is CellAssist, our healthcare AI platform. We are building AI systems for healthcare operations with a voice-first approach: AI receptionists for clinics and hospitals, automated patient triage, and admin operations powered by voice agents. We have active pilots running and are early in the product journey. If you want to work on something that is still being shaped, this is it. This role sits primarily on a US client project, with a partial contribution to CellAssist. You will own real systems, talk directly to clients, and be expected to figure things out without being handed a spec. ## What you'll do - Design and build backend systems in Python and FastAPI from architecture to production, owning the full lifecycle of what you ship - Architect and reason about platform-level concerns: service boundaries, data models, async workflows, infrastructure, and how decisions today affect the system six months from now - Build production-grade AI systems and agent workflows from first principles — multi-agent pipelines, code execution sandboxes, filesystem-based approaches, MCP server integrations, and custom tool design - Take a requirement end to end: understand it, design it, implement it, debug it, deploy it - Contribute to frontend work in React/Next.js when needed — feature changes, UI debugging, and enough fluency to work across the stack when the situation calls for it - Join client calls and do the work of understanding the domain, not just collecting feature tickets - Use AI-assisted development tooling (Cursor, Claude Code, agent skills, custom workflows) to ship fast without cutting corners ## What we're looking for - Backend engineering and platform thinking: You write clean, async Python and understand why systems are structured the way they are. FastAPI is your default for backend work and you're comfortable owning a service end to end. More importantly, you think at a platform level: how services are structured, where state lives, how async workflows are orchestrated, what failure modes look like, and how the codebase will hold up as the product and team scale. You've worked on systems with real users and real operational stakes, and that experience shows in how you make decisions. - Systems and low-level design: You think at the class, module, and data model level before writing code. Separation of concerns, error boundaries, retry logic, and observability are first-class concerns for you, not afterthoughts. This is not interview-prep system design — it's the kind of thinking that shows up in how you structure a pull request, how you name things, and how you handle edge cases before they become incidents. Understanding patterns like multi-tenancy, service isolation, and configuration management matters here, not because you'll design them from scratch on day one, but because working within them well requires knowing why they exist. - AI systems design: You understand how to build production-grade AI systems from first principles. You know Applied AI engineering beyond just wrapping OpenAI — you know what agent skills are, how dynamic context discovery works, when to use tool calling vs MCP servers, how filesystem-based approaches factor into agent design. You can design a pipeline that mixes LLM calls, deterministic logic, and tool use, and you know which problems don't need an LLM at all. You don't default to slapping RAG and embeddings over every problem, and you can write custom solutions without always reaching for LangChain or LlamaIndex. - End-to-end ownership: You can take a feature or requirement from a client conversation all the way to a deployed, working system. You ask good questions, translate ambiguity into concrete decisions, and don't wait to be unblocked. - Client communication: You can represent the engineering side on a call with a US client. That means asking the right questions, pushing back when something doesn't make sense, and learning enough about the domain to solve problems from first principles rather than just implementing what was asked. Client calls run at night (IST) — this needs to genuinely work for you. - Self-directed learning: You routinely figure out things you haven't done before. When you hit an unfamiliar API, an undocumented edge case, or a domain you know nothing about, you work it out. - Frontend working knowledge: React and Next.js at a working level — enough to make feature changes, understand what's happening on the UI side, and contribute when needed. Full ownership of the frontend is not required, but being blind to it is not an option. ## Tech stack - Backend: Python, FastAPI, PostgreSQL, GCP Cloud Run, Docker and Docker Compose, CI/CD and GitOps, Cloud Tasks, Pub/Sub, Redis, SQS, observability tooling - AI: LLM APIs and tool calling, prompt engineering, evals-first approach, RAG and embeddings, document parsing and data ingestion pipelines, sandbox agents, multi-agent orchestration, AI observability - Frontend: React, Next.js, TailwindCSS, shadcn/ui, Tanstack Query ## Nice to have - Hands-on GCP experience beyond Cloud Run (GCS, IAM, basic infrastructure setup) - Familiarity with LLMOps practices — evals infrastructure, prompt versioning, monitoring in production - A real AI-assisted development workflow that you've built or customised, not just defaulting to whatever ships with an IDE ## What we offer - ₹12–24 LP