Kautilya · Mumbai

Tech

We're hiring a Full-Stack + AI Engineer who actually builds and ships real production features - end-to-end. That means designing database schemas, writing and optimising queries, building secure APIs, building and hardening LLM agents, and delivering a clean, responsive frontend that works in the real world.

This role is for someone who is comfortable owning modules independently. You should be able to take a feature from idea to deployment without waiting for constant instructions. We work async-first. No daily standups. No micromanagement. The expectation is simple - ship consistently and take responsibility for what you build.

You'll be working on real product problems, not tutorials or sandbox projects. Performance, clean architecture, and practical decision-making matter here. We value developers who think through edge cases, care about code quality, and understand that shipping fast doesn't mean shipping sloppy.

Location: In-Office (Prabhadevi, Mumbai), Hybrid or Remote

Commitment: Full-Time (40 hrs/week)

No cover letter needed. Just show us what you've built and shipped: live products, GitHub repos, or a clear write-up of a tough technical problem you solved.

This is an AI-native role - we use AI heavily ourselves and expect you to use it to force-multiply your output, including on this form if you want. Just make sure your answers reflect real, specific experience: we'll dig into details in the interview, so vague answers (AI-assisted or not) will be obvious.

1. Your details2. Questions & assignment

Your details

Full name *

Email *

Phone *

Age *

LinkedIn profile URL *

Resume *PDF or DOC, up to 25 MB.

Where did you hear about this role? *

A few more questions

Full Name *

Email Address *please enter a valid email

Phone Number *

Current Location (City, Country) *

Preferred Work Model *

Years of Professional Development Experience *

Have you built and deployed production APIs using Node.js + Express + TypeScript? *

Describe one production API you built (tech stack, auth, validation, deployment, challenges) *

Rate your PostgreSQL skills (Supabase experience is a plus) *

Write a sample SQL query using JOIN (any example) *

Have you built a frontend using Vanilla JavaScript (without React)? *

Experience with Tailwind CSS? *

Describe your experience with AI/LLM-powered features you've built - agent frameworks (LangGraph, LangChain), model APIs (OpenAI, Anthropic, Gemini), and/or extracting structured data from messy documents (PDFs, Excel, scanned files). Include the architecture, how you handled reliability/edge cases, and one specific example. *

How do you personally use AI tools (Copilot, Cursor, Claude, ChatGPT, etc.) in your day-to-day engineering work? What do you let AI drive, and what do you always verify or write yourself and why? *

Say you've shipped an LLM-powered feature that works but is slow and/or expensive to run. Walk through how you'd think about optimizing it — what would you look at first, what trade-offs would you weigh, and how would you know you'd actually improved it (not just changed it)? *

Git Workflow Comfort Level *ie: Clean commit history, Meaningful commits, Pull Requests, Code Reviews, Branching strategies

Share links to something you've built and shipped (GitHub / Live Product). *

Describe a hard technical problem you solved recently. *

Experience With (Mention all that apply) *Supabase (Auth, RLS, Storage, Realtime) • React + TypeScript • OpenAI / LLM APIs • LangGraph / LangChain (agent frameworks) [NEW] • Document extraction / OCR (PDF, Excel parsing) [NEW] • Vite / Monorepo setups • Vitest / Playwright • Docker • CI/CD • Sentry

When can you start? *

Google Drive link your Resume *

Link to your Portfolio

Document Intelligence Agent - Messy Invoice Extraction

Read the full brief

Full Brief Context: You'll build a small end-to-end feature that mirrors real work here: turning messy, inconsistently-formatted documents into clean structured data via an LLM, with a working UI on top.

Build a tool that accepts vendor invoices (generate 4 sample files - 2 PDFs, 1 scanned/image PDF, 1 Excel - each formatted differently with sufficient) and extracts a common set of fields into structured records a human can review and correct. Required fields to extract: vendor name, invoice number, invoice date, line items (description, qty, unit price, total), and grand total.

Requirements

Backend: Node.js + Express + TypeScript API. Endpoint(s) to upload a document, trigger extraction, and fetch/list saved records.
LLM extraction: call an LLM (OpenAI/Anthropic/Gemini - your choice) to extract the fields above into a validated JSON schema. Handle malformed/incomplete model output (retry, repair, or flag for review) - don't assume the model gets it right first try.
Data layer: Postgres (Supabase preferred) schema for the extracted records, including a way to track extraction confidence/status (e.g. needs_review) and the raw source file reference.
Frontend: React + TypeScript + Tailwind. Upload a file, see extraction run, view results in a table, edit/correct a record, and see which fields the system flagged as uncertain.
Robustness: the 4 sample files are deliberately inconsistent (different layouts, one is scanned/low-quality). Your extraction should handle at least 3 of the 4 well and clearly flag the one it struggles with rather than silently returning wrong data.

Explicitly out of scope: auth, deployment/hosting, styling polish beyond "clean and usable," multi-user support.

Time expectation: Aim for 4-6 focused hours. We're not grading polish - we're grading judgment: how you handle unreliable model output, how you design the schema, and what you chose to skip and why.

What we're evaluating

1. Can you design and ship a real feature end-to-end without hand-holding
2. How you handle LLM unreliability (validation, retries, fallback, confidence signaling) rather than trusting raw output
3. Data modeling and API design choices
4. Frontend usability under real (messy) data, not the happy path
5. Written judgment, your README's explanation of trade-offs matters as much as the code

Submission

GitHub repo (public or invite the reviewer) + a short README covering setup, architecture decisions, what you'd do differently with more time, and known limitations. A 2-3 min Loom walkthrough is optional but appreciated.

GitHub repo link *

README (setup, architecture/trade-off notes, known limitations) *

Sample generated Inputs documents (included in repo, e.g. /samples/input) *

Sample extraction Outputs for the 4 documents (included in repo, e.g. /samples/output) *

(Optional) Loom walkthrough link

Anything you want us to know *

By submitting you agree we store your details to consider you for this and future roles.