TheTakeoff.AI

Software Development Engineer (SDE II) - Backend & Platform

Experience: 3+ years | Location: Bangalore (In-person) | Type: Full-time

Who We Are

TheTakeoff.AI is an AI-powered estimation engine built for industrial contractors. It reads P&ID; drawings (Piping and Instrumentation Diagrams), extracts component counts, and generates material takeoffs that would otherwise take estimators hundreds of hours to produce by hand.

The product targets specialty mechanical and petrochemical contractors on the US Gulf Coast, where a single refinery bid package can run 300+ P&IDs; and a full piping takeoff can consume 875 estimator-hours. We automate that first pass so the estimator can verify and refine 5 to 10 times faster than starting from scratch.

TheTakeoff.AI is built by ContraVault AI, a GenAI company founded by alumni of IIT-Delhi, NSUT, and XLRI Jamshedpur, with professional backgrounds spanning ITC, Microsoft, Nokia, GE, Alstom, ABB, and prior startups. The India-side platform already automates the tender and RFP lifecycle for enterprise teams. TheTakeoff.AI extends that document intelligence into industrial estimation for the US market.

About the Role

We're hiring an SDE II to build and own core parts of the backend powering an AI-first estimation product used by industrial contractors.

You'll design and ship production services that process large volumes of complex engineering drawings, run agentic AI workflows, and stay reliable under enterprise workloads. The work spans API design, data modeling, distributed document processing, container orchestration on Kubernetes, and the runtime systems that make LLM-powered extraction fast, accurate, and cost-efficient.

You'll work directly with the CTO and founding team, own architectural decisions end-to-end, and help set engineering standards as the team grows.

Because the product sits at the intersection of AI and a specialized industrial domain, prior exposure to estimation workflows, engineering drawings, tenders, RFPs, or a process-heavy industry is a firm requirement. It shortens the path from requirement to correct implementation, and it makes your technical judgment sharper on the problems that matter most here.

What You'll Do

- Design and own backend services end-to-end: architecture, implementation, testing, deployment, and operation of production APIs using Python (FastAPI) and/or Node.js (Express)
- Build scalable document processing pipelines for ingestion, parsing, OCR, structured extraction, and enrichment across engineering drawings, P&IDs;, isometrics, line lists, and specifications
- Engineer the serving layer for AI features: retrieval services, RAG pipelines (Retrieval-Augmented Generation), vector search, caching, and response streaming
- Architect asynchronous, event-driven systems: job queues, worker pools, retries, idempotency, and graceful degradation for long-running workloads
- Own data modeling and database performance: PostgreSQL schema design, indexing, query optimization, migrations, and partitioning, along with DynamoDB modeling where it fits
- Make deliberate system design tradeoffs: latency budgets, throughput targets, cost per request, concurrency limits, and capacity planning
- Build observability in from the start: structured logging, distributed tracing, metrics, alerting, and clear operational runbooks
- Strengthen platform security: authentication and authorization, multi-tenant isolation, audit trails,



encryption, and access control
- Build agentic AI systems: design and operate agent loops covering planning, tool selection, execution, reflection, and termination, along with multi-agent handoffs and human-in-the-loop checkpoints
- Engineer the agent runtime: tool registries and schemas, short- and long-term memory, state machines and checkpointing for resumable runs, step budgets, loop detection, timeouts, and safe fallbacks
- Make agents observable and measurable: per-step tracing, token and cost accounting, trajectory replay, guardrails, and evaluation harnesses that score agent outcomes over time
- Own cloud infrastructure on AWS: S3, Lambda, ECS, IAM, and infrastructure as code, with safe and repeatable deployments
- Run workloads on Kubernetes: containerize services, manage deployments and rollouts on EKS, configure autoscaling for bursty AI workloads, and tune resource requests, limits, and node pools for cost and stability
- Ship LLM-powered features with the AI team: prompt orchestration, structured extraction from engineering documents, retrieval tuning, and response quality benchmarking
- Raise the engineering bar: thoughtful code reviews, testing strategy, CI/CD, technical documentation, and mentoring engineers and interns

What You'll Bring

- 3+ years of skilled software engineering experience building and operating production backend systems
- Domain experience with estimation, tenders, RFPs, or process-heavy industries (required): you've built software for, or worked directly within, workflows involving material takeoffs, quantity surveying, cost estimation, bid preparation, RFPs, RFQs, RFIs, EOIs, or similar solicitation and procurement processes. This can come from EPC (Engineering, Procurement, and Construction), industrial or process plant estimation, procurement or e-procurement platforms, bid and proposal management, contract lifecycle management, or compliance and eligibility evaluation. Time spent in a relevant industry counts equally: oil and gas, petrochemical, refining, energy and utilities, construction and infrastructure, defence, healthcare, manufacturing, logistics, or IT and consulting services. Experience with GovTech, LegalTech, ProcureTech, ConstructionTech, or supply chain products also qualifies. What matters is that you understand how these documents are structured, evaluated, and responded to
- A track record of shipping systems that real users depend on, and of keeping them healthy in production
- Strong system design instincts and the ability to reason through tradeoffs such as latency versus cost, or consistency versus availability
- Clean, well-tested, readable code and genuine care for long-term maintainability
- High ownership: you scope your own work, unblock yourself, and drive things to completion
- Clear written and verbal communication, and comfort giving and receiving direct feedback
- Adaptability in a fast-moving environment where priorities evolve quickly
- Persistence: you see work through to the finish

Technical Skills

Core

- Backend:



Python (FastAPI) and/or Node.js (Express), with a solid grasp of async programming, concurrency, and performance characteristics
- Databases: PostgreSQL, including schema design, indexing, query planning, and performance tuning at scale
- APIs: REST API design, authentication and authorization, versioning, pagination, rate limiting, and idempotency
- System design: Distributed systems fundamentals, caching strategies, message queues, event-driven architecture, and horizontal scaling
- Cloud: AWS (S3, Lambda, ECS, IAM), with working knowledge of deployment, networking, and cost management
- Containers and orchestration: Docker, plus hands-on Kubernetes (deployments, services, ConfigMaps and secrets, health probes, resource limits, and rolling updates)
- Engineering practice: Git workflows, code review, automated testing (unit, integration, end-to-end), and CI/CD
- Operations: Diagnosing and resolving production issues across services, databases, and infrastructure

Preferred:
- AI/LLM engineering: LLM APIs, prompt engineering, RAG pipelines, embeddings, and chunking strategies
- Vector search: pgvector or OpenSearch, including indexing strategies, hybrid search, and retrieval quality tuning
- Agentic AI systems: Agent loop design (plan, act, observe, reflect), tool-calling and function-calling pipelines, multi-agent orchestration, memory and context management, and Model Context Protocol (MCP)
- Agent frameworks: LangGraph, LangChain, LlamaIndex, CrewAI, AutoGen, or equivalent, along with durable execution engines such as Temporal or AWS Step Functions
- Agent reliability: Guardrails, output validation, retry and repair strategies, cost and step budgeting, sandboxed tool execution, and trajectory evaluation
- Kubernetes at depth: EKS, Helm, HPA/KEDA autoscaling, ingress and networking, StatefulSets, Jobs and CronJobs for batch AI workloads, and GitOps with ArgoCD or Flux
- NoSQL: DynamoDB data modeling and access-pattern design
- Document processing: PDF parsing, OCR, table extraction, layout-aware extraction, and engineering drawing interpretation
- Domain tooling: Estimation and takeoff software (Accubid, FastPIPE, PlanSwift, Bluebeam, or equivalent), e-procurement and tender portals (GeM, CPPP, SAM.gov, TED, or equivalent), contract lifecycle management systems, bid evaluation and scoring engines, or automated compliance and eligibility checking
- Infrastructure as code: Terraform or AWS CDK

How We Work

- Small, senior team with direct access to the founders
- Fast decision-making and short feedback loops from idea to production
- Written clarity: design docs, considered code reviews, and shared context
- Ownership over outcomes, with the autonomy to choose how you get there

Interview Process

1. Intro call: your background, and what you want to build next
2. Technical deep dive: a walkthrough of a system you've built end-to-end
3. Practical exercise: a scoped, realistic engineering problem
4. System design discussion: architecture for an agentic, document-heavy AI pipeline running at scale
5. Founder conversation: working style, ownership, and mutual fit

What We Offer

- Compensation as per market standards
- Meaningful ownership of core platform architecture
- Flexible working hours
- In-person: Bangalore
- Direct mentorship from and collaboration with the founding team
- Hard, high-impact problems in document intelligence and applied AI

📌 SDE 2 (Bengaluru)
🏢 the takeoff ai
📍 Bengaluru