Founding Engineer

Blaugarnet Inc.; Pune District; Hybrid; INR 5,000,000 - 6,000,000; Full time

Benefits offered by this job

Founding equity

Job summary

Blaugarnet Inc. seeks a Founding Engineer in India to build the core AI system end to end and set architectural direction from day one. You’ll own the product’s technical anchor and collaborate across backend, AI, and DevOps to ship production-grade systems.

As an IC with high agency, you’ll translate customer intent into architecture, influence engineering practices, and drive the product forward at startup speed from Pune in a hybrid setup with equity on offer.

Qualifications

• 6–8 years of software engineering experience with deep backend expertise.
• AI-native development in production experience.
• 2–3+ years building AI/GenAI systems in production.
• Deterministic orchestration of LLM workflows with state-machine style.

Responsibilities

• Build the core AI system end to end and guardrails for production.
• Take product from demo-grade to production-grade, scalable and observable.
• Own architecture and technical direction across system components.
• Set and maintain engineering standards, reviews, and practices.
• Stay close to customer feedback to drive architectural decisions.
• Wear multiple roles across backend, AI, DevOps, and CI/CD.

Skills

Backend engineering

Python

AI/GenAI

LLM workflows

Governance

RAG

Postgres

Docker

CI/CD

Git

IC leadership

Startup mindset

Tools

Python/FastAPI

PostgreSQL

pgvector

Job description

Blaugarnet is building the Intent Layer for AI-driven software — a layer that sits above the coding tools your team already loves and below business strategy. AI can now write most of the code. What it can't do on its own is make sure that what gets built is what the business actually intended, or prove who decided what, and why. Our product captures business intent from raw, messy sources, runs it through a governed, human-in-the-loop system that deliberates each decision from multiple expert perspectives, and produces human-authorized blueprints an AI agent can build from correctly, backed by a permanent, append-only record of every decision made along the way. Our enterprise product is live in early access; a self-serve product is on the near roadmap.

We're small, early, and moving fast.

The role

As our Founding Engineer in India, you're one of our most important early hires: part builder, part architect, part technical anchor. You'll write the core of the product and make the architectural calls the rest of the team builds on. Early on you'll be deep in code every day; over time you'll increasingly shape technical direction and engineering practice — the technical anchor for our India team from day one. This is an individual-contributor role: deep technical ownership and influence, without people-management responsibilities.

If you thrive on ambiguity, want your decisions to shape a company (not just a codebase), and care about building reliable AI systems rather than demos, read on.

What you'll own

Build the core AI system end to end — the core reasoning and deliberation engine and its context engineering (planning, tool use, memory, validation), retrieval pipelines over structured and unstructured data, and the evaluation frameworks and guardrails that make it reliable in production.

Take the product from demo-grade to production-grade — scalable, observable, cost-aware AI services that real enterprise customers depend on.

Own architecture and technical direction — choose the frameworks, patterns, and infrastructure (including the system-of-record data architecture and the on-prem / VPC / regulated deployment posture); live with the consequences; set the engineering practices the future team inherits.

Set the technical bar — be the reviewer and standard-bearer for architecture, code quality, velocity, and reliability; raise the level of the work around you through code review and technical direction.

Stay close to the customer and the product — translate real customer intent and feedback directly into architecture and features; help decide what's worth building.

Wear every hat early — backend, AI, DevOps, and CI/CD, because that's what building from zero to one requires.

What you'll bring (required)

6-8 years of software engineering, with deep, hands‑on backend expertise in a modern typed/async stack (we use Python/FastAPI today) — strong service and API design.

AI-native development as your default mode — you work with coding agents (Claude Code, Cursor, or similar) daily to design, build, and verify production systems.

2-3+ years building AI / GenAI systems in production — systems real users depend on, not prototypes.

Deterministic orchestration of LLM workflows — you've built systems where control flow, authority, and guardrails live in engineered machinery (state-machine / workflow-engine style), not in the model's own discretion; planning, tool use, memory, and context engineering happen inside that structure.

Governance and guardrails enforced outside the model — deterministic checks on non-deterministic output, so the system's rules hold even when the model doesn't cooperate. (We're building a governed system where the machinery holds authority — not autonomous agents.)

RAG in production — vector databases (e.g. pgvector), embedding pipelines, and retrieval over structured and unstructured data.

Relational data modeling under correctness constraints — you build systems of record, not caches: append‑only / immutable data, provenance and lineage integrity, sequence and transactional correctness, schema evolution under load. Strong SQL / Postgres.

LLM API integration across providers (OpenAI, Anthropic, Gemini), including multimodal pipelines where relevant.

Evaluation-harness design — because our output is non-deterministic and quality is a matter of judgment, you've built the eval sets, benchmarks, and regression checks that let a team change a model or a prompt without silently degrading quality.

A discipline for cost and performance — prompt engineering and cost/performance trade-offs (token tracking, model-selection heuristics, caching).

A discipline for cost and performance — prompt engineering and cost/performance trade-offs (token tracking, model-selection heuristics, caching).

Docker, Git, and CI/CD (e.g. GitHub Actions) with containerized deployment.

Proven zero-to-one ownership — you've built and shipped products from nothing to production, defined the spec yourself, and made architecture calls under real uncertainty.

Technical leadership as an IC — you raise the bar for the engineers around you through architecture, code review, and mentorship, and set standards others follow — without needing a manager title or direct reports.

Startup temperament — high agency, comfort with ambiguity, a bias to ship, and direct communication.

Nice to have

MCP (Model Context Protocol) tooling and agent‑interoperability standards.

Open-source contributions to the AI ecosystem (LangChain, vector DB integrations, etc.).

Public technical writing, PyPI packages, or talks on LLMs, RAG, or agents.

Comfort driving coding agents (Claude / Cursor) to build and integrate a standard React / TypeScript frontend against your API contracts, rather than hand‑crafting UI.

Experience in regulated or high-stakes enterprise domains (governance, audit, compliance).

Why this role

Founding-level ownership and equity — you're a cornerstone of the company, with compensation to match: ₹50–₹60 LPA including performance bonuses + founding equity

The most consequential engineering seat in India — you don't inherit a system, you define it.

Real AI, real stakes — a live enterprise product in early access, not a science project.

Work beside a founder who has built at the top — 25 years of AI and product at Google and Adobe, in the room with you daily.

Direct line to the founders — your judgment shapes the product and the company.

Grounded, not hype-driven — customer-focused and deliberate; we hire carefully and invest in the people we bring on for the long run.

Compensation & Logistics

Location: Pune, India — hybrid.