Senior Full-Stack AI Engineer

What matters most

• First-Principles Agentic and Multi-Agent Architecture

  The role prioritizes designing and implementing agentic workflows from first principles, specifically focusing on agent orchestration, MCP server and tool integrations, state handling, memory management, evals, and guardrails without over-relying on high-level wrapper frameworks like LangChain.

• Robust Backend and SaaS Engineering in Python and FastAPI

  Core engineering centers on writing idiomatic Python and FastAPI backends, owning system architecture from HLD to LLD, and addressing multi-tenancy, service boundaries, async workflows, and production data models for scalable enterprise deployments.

• Production LLM Optimization and Cost-Latency Governance

  Engineers are expected to handle real-world LLM operational constraints, including prompt engineering, context window management, prompt caching, memory strategies, and latency/reliability trade-offs in customer-facing production systems.

• End-to-End Feature Ownership and Direct Client Engagement

  The position requires taking features from initial concept through design, code review, testing, deployment, and monitoring, combined with direct participation in night IST discussions with US clients to decipher domain requirements without pre-written specs.

Likely challenges to think through

• Balancing First-Principles Agent Implementations Against Framework Abstractions

  Preparation Hypothesis: The team emphasizes building agents without wrapper libraries to ensure granular control over memory, latency, and tool execution. The trade-off is higher boilerplate and custom state management versus faster prototyping with out-of-the-box abstractions. Prepare by practicing building custom agent loops, state machines, and Model Context Protocol (MCP) tool integrations purely with native Python and async primitives.

• Maintaining Code Rigor Under Accelerated AI-Assisted Workflows

  Preparation Hypothesis: Using tools like Cursor or Claude Code speeds up code output but increases the risk of subtle bugs, security flaws, or unmaintainable logic in human and AI-authored PRs. Prepare concrete code review criteria covering edge cases, async concurrency issues, and defensive guardrails tailored to AI-generated code.

• Handling Non-Deterministic LLM Behavior and Production Latency

  Preparation Hypothesis: Deploying multi-agent systems to real users introduces compounding latency and reliability vulnerabilities from flaky tool calls or unpredictable model responses. Prepare by outlining robust evaluation frameworks, fallback heuristics, context window pruning, and prompt caching patterns used to enforce strict SLAs.

• Navigating Asynchronous US Client Communication and Unspecified Requirements

  Preparation Hypothesis: Shifting between US night calls (80% client work) and independent daytime execution demands rapid domain translation without hand-held specifications. Prepare examples demonstrating how to clarify ambiguous business objectives, document architectural trade-offs, and maintain sustainable routines across time zones.

Topics to prepare

• First-Principles Agentic Orchestration and State Management

  Relevance: Required duty to design and build agentic and multi-agent AI systems from first principles, specifically without defaulting to high-level framework wrappers like LangChain or LlamaIndex. Exercise: Diagram and write out the state transition schema for a multi-agent system handling user requests, detailing message history maintenance, tool invocation loops, context isolation between agents, and deterministic guardrail checks.

• Production LLM Optimization and Latency/Cost Management

  Relevance: Explicit requirement covering LLM-layer engineering, specifically prompt engineering, context management, memory strategies, and prompt caching to govern latency, cost, and reliability. Exercise: Compare semantic caching vs exact-match prompt prefix caching, and write a technical justification detailing when each approach minimizes token costs and response latency for a multi-turn conversational agent.

• SaaS Multi-Tenancy and Backend Architecture Principles

  Relevance: Core requirement for software architecture ownership, designing systems from scratch across HLD/LLD, multi-tenant patterns, service boundaries, and asynchronous workflows. Exercise: Outline an architectural design document for a multi-tenant API serving isolated enterprise clients, detailing tenant data isolation, shared vs dedicated vector stores, and rate-limiting strategies for external LLM endpoints.

• Trade-Off Reasoning in AI and Backend Systems

  Relevance: Mandatory qualification requiring engineers to justify technology choices over alternatives (e.g., why RAG vs no RAG, vector DB selection, or deployment models) without framework stacking. Exercise: Draft a structured trade-off evaluation comparing a pure tool-calling agent against an embedding-based retrieval pipeline (RAG) for answering structured domain queries, articulating latency, maintenance, and failure modes.

• LLMOps, Evals, and AI Observability

  Relevance: Listed under preferred qualifications for evals infrastructure, prompt versioning, and production observability. Exercise (Inferred preparation suggestion): Formulate an offline and online evaluation rubric for assessing voice or text agents, defining concrete metrics for hallucination detection, tool-call accuracy, and latency tracing.

Skills to revise

• Rapid Python and FastAPI Defect Resolution and Async Programming

  Relevance: Directly assessed in Round 1 proctored live coding (fixing missing Python/FastAPI code in 20 minutes) and tests mandatory core fundamentals (OOP, decorators, generators, async). Exercise: Practice downloading an incomplete FastAPI repository and under a 20-minute timer implement missing async endpoints, Pydantic request models, custom decorators, and async database session handling.

• Vanilla Python Agent Implementation and MCP Tool Integration

  Relevance: Directly matches the take-home assignment and preferred skill of building agentic systems without LangChain or LlamaIndex, integrating Model Context Protocol (MCP) servers and tools. Exercise: Implement an autonomous agent loop from scratch using standard Python async functions and an LLM client library that reads an MCP tool schema, dispatches local tool functions, and handles tool execution errors gracefully.

• AI-Assisted Accelerated Engineering (Cursor / Claude Code)

  Relevance: Source specifies using AI-assisted tooling (Cursor, Claude Code) to ship fast while maintaining rigorous code quality and architectural integrity. Exercise: Build a small end-to-end microservice using Cursor or Claude Code, practicing prompt workflows to scaffold FastAPI routes, then perform a manual security and correctness audit of the generated code.

• Full-Stack Integration with React, Next.js, and TypeScript

  Relevance: Stated requirement to contribute to frontend work and debug UI issues across React, Next.js, or TypeScript without needing full ownership. Exercise: Build a minimal Next.js client with TypeScript that connects to a FastAPI streaming response endpoint via Server-Sent Events (SSE) and displays real-time agent output with loading and error boundaries.

• Practice rapid Python and FastAPI live debugging under time constraints

  Prepare for the 20-minute proctored coding test by completing timed exercises where you unpack a boilerplate FastAPI codebase, fix missing endpoints or broken dependency injections, and handle core async routines, decorators, and generators without looking up basic syntax.

• Build a production-grade agentic walkthrough based on first principles

  Draft a structured technical walkthrough of a previously shipped multi-agent or agentic system, detailing its orchestration, memory handling, tool or MCP server integrations, and guardrails implemented in pure Python without reliance on frameworks like LangChain or LlamaIndex.

• Document architectural trade-offs for SaaS multi-tenancy and async pipelines

  Create a clear comparison sheet showing high-level and low-level design decisions you have made, specifically covering tenant isolation, service boundaries, async message workflows (e.g., Pub/Sub or Cloud Tasks), and how trade-offs like RAG versus direct context injection were evaluated.

• Prepare concrete evidence of production LLM engineering and optimization

  Compile concrete explanations showing how you implemented prompt caching, dynamic context management, and memory strategies in past projects to manage latency, operational token costs, and response reliability under real production workloads.

• Review React, Next.js, and TypeScript frontend integration patterns

  Spend focused practice reviewing Next.js and React codebases to ensure you can quickly navigate component hierarchies, implement UI changes, and debug client-side API integrations connecting to Python backend services.

• Formulate practical questions about client project scope and the CellAssist platform

  Draft specific questions for the team covering how time is allocated between the 80% US client project and the 20% CellAssist healthcare voice agent platform, operational expectations for night IST calls, and the current evaluation harness used in their AI pipelines.