About the role :-

We build an AI product where multiple large language models answer a question and a judge model synthesizes a consensus. It's a small, fast-moving team that develops AI-natively — we design, build, test, and ship with an agentic coding assistant (Claude Code) as a core part of the workflow, using a structured "write the spec, review it, build it, test it, ship it" loop.

We're looking for one senior engineer to work directly alongside the founder. You should be stronger than a typical full-stack hire — someone who can own features end to end, raise the technical bar, and get more out of AI-assisted development than most engineers do, while still having the fundamentals to know when the AI is wrong.

This is not a "prompt the AI and hope" role. You'll pair with AI to move fast, but you own correctness, architecture, tests, and production.

What you'll do

- Ship features end to end — from a written spec through backend, frontend, tests, and production deployment, on a codebase that touches multi-model LLM orchestration, streaming, billing, and analytics.
- Develop AI-natively — work productively with an agentic assistant, but review every change with a senior engineer's judgment. Drive the AI; don't be driven by it.
- Write and refine SPECs — turn product ideas into clear technical specs before code is written, including edge cases, data model, and test plan.
- Own the database layer — design and evolve PostgreSQL schemas, write correct and performant SQL (JSONB, indexing, transactions, migrations), and reason about data integrity in production.
- Write real tests — unit tests, database-backed integration tests, and end-to-end browser tests. Treat "it passed CI and the happy path and the edge cases" as the definition of done.
- Run the quality workflow — use structured review and reflection practices (engineering plan review, design review, code review, retrospectives, and "learnings" capture) as a normal part of shipping, not an afterthought.
- Operate in production — comfortable in the terminal: deploy via CI/CD, manage servers over SSH, read logs,



manage environment/config and feature flags, and debug live issues calmly.
- Guard quality and safety — treat correctness, security, secrets hygiene, and privacy/compliance (e.g., GDPR-style data handling) as first-class concerns.

Must-have qualifications

- 5+ years building and shipping production software (title flexible; we care about depth, not years).
- Strong Python — you can read and write a nontrivial async web codebase (e.g., FastAPI) confidently.
- Strong SQL / PostgreSQL — schema design, query performance, transactions; you can debug a slow or wrong query yourself.
- Command-line fluency — git, shell, SSH, log reading, running and interpreting build/test/deploy commands without hand-holding.
- Frontend capability — comfortable in a modern React + TypeScript codebase (components, state, API integration). You don't have to be a designer, but you can build and fix UI.
- Testing discipline — you write tests by default and think about edge cases and failure modes, not just the demo path.
- Genuinely effective with AI coding tools — you've used AI assistants (Claude Code, Cursor, Copilot, or similar) to ship real work and can speak to where they help and where they mislead.
- Clear written communication — you can write a spec, a pull-request description, and a design decision that another human (or an AI) can act on.

Nice to have

- Experience with LLM / AI application development — model orchestration, prompt design, streaming (server-sent events), evaluations, or tools like litellm.
- CI/CD and cloud ops — GitHub Actions, feature-flag-driven releases, deploying to VPS / EC2, nginx, systemd.
- Payments / billing (e.g., Stripe),



transactional email, or product analytics / ad-platform integrations (GA4, Meta) experience.
- Familiarity with privacy / compliance (GDPR, data-subject requests, secrets management).
- A habit of retrospectives and continuous learning — capturing what broke and why so it doesn't break twice.

How we work

- Spec first, then build. Meaningful work starts as a written spec that gets an engineering (and often design) review before implementation.
- AI-augmented, human-owned. We use AI heavily to draft, refactor, and test — but a human owns every merge, and "the AI wrote it" is never an excuse for a bug.
- Small surface, high trust. Few people, direct communication, real ownership. You'll touch backend, frontend, database, and deploys.
- Ship behind flags. Risky changes ship dormant behind feature flags and get validated on a beta environment before production.
- Quality is a workflow, not a vibe. Reviews, tests, retrospectives, and learnings are part of every cycle.

Our stack

- Backend: Python (FastAPI, async), PostgreSQL (asyncpg), multi-model LLM orchestration (litellm), server-sent events.
- Frontend: React, TypeScript, Vite, Tailwind CSS.
- Infrastructure: GitHub Actions CI/CD, DigitalOcean + AWS (EC2 / RDS), nginx, systemd, feature flags.
- Testing: pytest (unit + database integration), Playwright (browser end-to-end).
- Workflow: an agentic coding assistant plus a structured skill set for spec review, design review, code review, QA, retrospectives, and deployment.
- Also in the mix: Stripe billing, transactional email, GA4 / Meta analytics.

What we're really testing for

Someone who is fast because they're good, not fast because they skip steps. Who can hold a whole feature — data model, API, UI, tests, deploy — in their head, use AI to move quickly, and still catch the bug the AI introduced. If you get energy from owning things end to end on a small team, this is a great fit.

Pay: Up to ₹50,000.00 per month

Benefits:

- Adaptable schedule

Work Location: In person

📌 Python Full Stack Developer (India)
🏢 Variance Infotech
📍 India