Uplers
Website:
uplers.com
Company:
https://www.linkedin.com/company/weareuplers
Seniority: Not Applicable
Industries: Technology, Information and Internet
Job details:
Experience: 2.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, AI Agents, rag, Llm pipelines
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.
How to apply for this opportunity?
- Step 1: Click On Apply! And Register or Login on our portal.
- Step 2: Complete the Screening Form & Upload updated Resume
- Step 3: Increase your chances to get shortlisted & meet the client for the Interview!
About Uplers:
Our goal is to make hiring reliable, simple, and fast. Our role will be to help all our talents find and apply for relevant contractual onsite opportunities and progress in their career. We will support any grievances or challenges you may face during the engagement.
(Note: There are many more opportunities apart from this on the portal. Depending on the assessments you clear, you can apply for them as well).
So, if you are ready for a new challenge, a great work environment, and an opportunity to take your career to the next level, don't hesitate to apply today. We are waiting for you!
Click on Apply to know more.