Fullstack AI Product Engineer

Uplers Solutions Private Limited.; India; Remote; INR 2,500,000 - 5,000,000; Full time

Benefits offered by this job

Direct exposure to AI product

Small technical team

Flexible remote work

Hands-on with latest models

Job summary

CellStrat is seeking a Full-Stack AI Product Engineer to join our US client project with responsibilities across backend, AI systems design, and occasional frontend work with React/Next.js. You will own real systems, engage directly with clients, and operate with minimal specs.

The role emphasizes end-to-end ownership, strong Python/FastAPI skills, and a platform-thinking approach. Remote work is offered, with IST-friendly coordination for night calls.

Qualifications

• Must have skills: Python, FastAPI, Agentic AI, Multi-Agent AI.
• Experience designing backend systems with production-grade AI components.
• Ability to own features from client discussion to deployment.

Responsibilities

• Design and build backend systems in Python and FastAPI from architecture to production, owning the full lifecycle.
• Architect platform-level concerns: service boundaries, data models, async workflows, infrastructure decisions.
• Build production-grade AI systems and agent workflows: multi-agent pipelines, tool design, and MCP server integrations.
• Take a feature from client conversation to a deployed system with minimal handholding.
• Contribute to frontend work in React/Next.js when needed for end-to-end delivery.
• Join client calls, understand domain, and translate requirements into concrete actions.
• Use AI-assisted tooling to ship quickly without compromising quality.

Skills

Python

FastAPI

Agentic AI

Multi-Agent AI

Tools

PostgreSQL

GCP Cloud Run

Docker

Docker Compose

CI/CD

GitOps

Redis

SQS

Job description

Experience: 1.00 + years

Salary: Confidential (based on experience)

Shift: (GMT+05:30) Asia/Kolkata (IST)

Opportunity Type: Remote

Placement Type: Full time Permanent Position

(*Note: This is a requirement for one of Uplers' client - CellStrat)

What do you need for this opportunity?

Must have skills required:

Python, FastAPI, Agentic AI, Multi-Agent AI

CellStrat is Looking for:

Job Description

Full-Stack AI Product Engineer

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

Python and FastAPI

You write clean, async Python and understand why things are structured the way they are. FastAPI is your default for backend work and you're comfortable owning a service end to end.

Backend Engineering and Platform Thinking

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, 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.

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 Docker Compose CI/CD GitOps Cloud Tasks Pub/Sub Redis SQS Observability

AI: LLM APIs Tool Calling Prompt Engineering Evals RAG Embeddings Document Parsing Data Ingestion Sandbox Agents Multi-Agent Orchestration AI Observability

Frontend: React Next.js TailwindCSS shadcn/ui

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 you've built or customised, not just defaulting to whatever ships with an IDE.

What We Offer

• Direct exposure to AI product and client engineering on real systems — not internal tooling or mock projects.
• A small, technical team where your architecture decisions actually ship.
• Flexible remote work for the right person.
• Constant hands-on exposure to the latest models, cloud infrastructure, and agent tooling as the field moves.

A Note on Fit

This is not a role for someone who needs clear specs to get started or wants to be managed closely. The people who do well here are genuinely curious, form opinions quickly from first principles, and have a high tolerance for ambiguity. If you've shipped something that involved a real backend, real infrastructure, and real users — we want to hear about it.