Software Engineer 3

Who we are:

Arcadia is the AI-powered energy intelligence platform for businesses. We replace fragmented tools and manual workflows with one platform to pay utility bills, buy energy, and advance sustainability — across every location, at enterprise scale.

Trusted by Fortune 2000 companies, Arcadia combines unified data, AI-powered analytics, and expert advisory to help enterprise teams save money, mitigate risk, and cut carbon.

We deliver this through three comprehensive solutions:

Utility Bill Management: Automating the entire utility bill lifecycle — from data capture and validation to payment processing and auditing.

Energy Procurement Advisory: Bringing together comprehensive data, AI-powered analytics, market expertise, and a strong partner network to make sophisticated procurement options accessible to all.

Sustainability Reporting: Verified emissions data with seamless integration into leading sustainability platforms.

Tackling the world's most complex energy challenges requires diverse thinking. We're building teams of people from different backgrounds, industries, and disciplines — united by a belief that energy management should be simple, intelligent, and a genuine driver of business value.

Benefits

• Competitive compensation based on market standards.
• Hybrid working model with a remote-first policy, anchored in Chennai
• Flexible leave policy
• Medical insurance (self + 5 family members)
• Flexible benefit plan, awards and bonus
• Annual performance cycle and quarterly engagement activities
• Office located in the heart of the city if you need to step in for any purpose
• A supportive engineering culture that values diversity, empathy, teamwork, trust, and efficiency

Eliminating carbon footprints, eliminating carbon copies.

Here at Arcadia, we cultivate diversity, celebrate individuality, and believe unique perspectives are key to our collective success in creating a clean energy future. Arcadia is committed to equal employment opportunities regardless of race, color, religion, gender, sexual orientation, gender identity or expression, national origin, age, disability, genetic information, protected veteran status, or any status protected by applicable federal, state, or local law. While we are currently unable to consider candidates who will require visa sponsorship, we welcome applications from all qualified candidates eligible to work in India.

What we're looking for:

We are seeking a Software Engineer 3 (L3) to join the team that turns millions of utility documents into structured, trustworthy data — data our customers rely on to pay bills correctly, buy energy well, and report emissions accurately.

This is a senior individual contributor role that sits deliberately on both sides of a line most companies keep separate: you will own distributed backend systems and the AI that runs inside them. Utility bills are one of the hardest document problems in the wild. Thousands of issuers, no shared format, decades of inherited layout quirks, and scans that range from pristine to barely legible. Getting a number right most of the time is easy; getting it right reliably, at volume, at a cost that makes business sense, is the actual job.

That means the problems you'll work on don't stay in one layer. A drop in accuracy might be a prompt regression, a model choice, a document-quality issue, or a bug three layers down. A throughput ceiling might be concurrency limits, scaling behaviour, or an unindexed query. We're looking for someone who follows the problem wherever it goes instead of handing it off at the boundary.

We're at a genuinely interesting point. The platform is live and scaling, there are new capabilities to build from scratch, and there is real pressure to push accuracy up while driving cost per document down. You'll have unusual latitude to shape how we get there.

Our stack is Python, FastAPI, and PostgreSQL, running on AWS and Kubernetes with automated CI/CD. 

What you'll do:

• Own features end to end — from design through implementation, tests, deployment, and the follow-up work nobody assigned you. You will ship to production in your first few weeks.
• Build document intelligence across the whole lifecycle — intake and readability (native text layer versus scan, rasterization, OCR, VLM), classification of what arrived and from which issuer, extraction of unstructured content into verifiable structured data with field-level confidence, and resolution of the result against our own records. Deciding which documents deserve an expensive model call and which a deterministic parse already handles is part of the design, not a tuning detail.
• Design and ship multi-agent workflows — decompose the hard parts of a document into specialist agents that work the problem together over shared memory: classification, extraction, audit of the result against the source, root-cause analysis when something fails, and the feedback loop that acts on what they find. Each agent gets the tools and context it needs and passes state to the next, and you build the whole thing with the turn limits, retries, and cost ceilings that let it run unattended. Work out where a multi-agent design genuinely beats a single prompt and prove it on real documents; saying an agent is the wrong tool is part of the job too.
• - Orchestrate the pipeline reliably  — distributed Python services that process documents reliably at high volume, degrade gracefully under load, and recover from partial failure without human intervention. At-least-once delivery, duplicate and late messages, idempotency, and timeout behavior are design inputs, not surprises.
• Verify, escalate, and close the loop — checks that compare a result against the source document and our domain rules, confidence thresholds that decide what ships automatically, clean routing of everything else to human review, and the machinery that turns corrections, audit failures, and low-confidence flags back into pipeline action: a re-run, a different engine, a prompt or model change, or a new case in the evaluation set.
• Build the evaluation discipline — ground-truth datasets, metrics that fit each capability, shadow and replay runs that compare approaches against live production traffic, and regression gates that stop a change from shipping when quality drops.
• Model and query data properly — schema design, migrations, indexing strategy, and performance work when things get slow at scale.
• Own the deployment path for what you build — infrastructure configuration, scaling, and operational readiness. There is no separate team that does this for you.
• Own observability for the AI and the systems around it — agent traces, tool inputs and outputs, the prompt and model version actually used, cost per document, and the alerts that would have caught the last incident sooner. You should be able to reconstruct what a model was given, what it returned, what it cost, and why the pipeline acted on it.
• Write tests that mean something — we care about tests that catch real regressions, not coverage theater.
• Raise the bar in code review — give substantive feedback, and mentor mid-level engineers toward the judgment to work through ambiguous problems on their own.
• Write the documentation the team actually needs — design decisions, runbooks, and post-incident notes that get closed rather than filed.

What will help you succeed:

Must-haves:

• 6–10 years of professional software engineering experience, with a clear track record of owning non-trivial projects end to end — we will ask you to walk us through a system you designed, what you got wrong, and what you'd do differently.
• Strong Python — modern Python including async/await, type hints, and structured data modeling. You write code that is readable by the next person, and you know when a clever abstraction is the wrong call.
• Production experience with FastAPI or an equivalent async web framework, including how to structure a service beyond a single file.
• Practical experience shipping LLM-backed features to production — prompt design and iteration, structured output, handling non-deterministic failures, evaluating quality systematically, and managing cost and latency. A demo notebook is not the same as a system that runs unattended on real customer data, and we're looking for the latter.
• Multi-agent workflow design — tool and function calling, loop control and termination, and giving a model the ability to verify or correct its own output. Beyond a single agent, we care about the step up to several agents working on one problem: decomposing it into specialists, deciding what state is shared and what stays local, handing context between agents without losing or corrupting it, and keeping the result explainable when three agents contributed to one answer. You should be able to talk concretely about when an agentic approach earned its keep, when it didn't, and how you decided. Whether you built it on a framework (LangGraph, PydanticAI, CrewAI, the OpenAI Agents SDK) or by hand matters less to us than whether you understand state and shared memory, retries, turn limits, and cost control across a whole workflow rather than a single call.
• Hands-on production experience across the agentic AI stack — vision-language models from Anthropic, OpenAI, or Google; the OCR and parsing tools an agent reaches for, such as Tesseract, AWS Textract, or Azure Document Intelligence; and tracing and evaluation tooling such as Langfuse or LangSmith, used to debug a real failure rather than to tick a box. The judgment tying them together is what matters most: knowing when a deterministic parse beats a model call, and where a vision model quietly fails on a degraded scan.
• Distributed systems judgment — you design for partial failure by default. Retries with backoff, dead-letter queues, circuit breakers, and idempotency keys are tools you've actually reached for, not terms you've read about.
• Hands-on AWS experience building event-driven systems — S3, SQS, SNS, and at least one workflow orchestrator (Step Functions, Airflow, Temporal, or similar). You should be able to explain idempotency, at-least-once delivery, and why exactly-once delivery is a myth.
• Solid SQL and relational data modeling with PostgreSQL — schema design, indexing, migrations, and diagnosing a slow query from an execution plan. ORM experience is a strong plus.
• Working comfortably with Docker and Kubernetes — you can debug a failing pod, reason about resource limits, and deploy your own service without waiting on someone else.
• A real testing discipline — meaningful mocking of external dependencies, and the instinct to write the test that reproduces the bug before fixing it.
• CI/CD fluency — GitHub Actions or equivalent, and an understanding of what makes a deployment safe to roll back.
• Daily fluency with AI coding tools — Claude Code, Cursor, Copilot, Codex, or equivalent. We use them heavily, and we expect you to get real leverage from them while owning everything that ships under your name: reviewing generated code as closely as a colleague's, catching the answer that looks right and isn't, and judging which problems are worth handing to an agent at all.
• Debugging tenacity across layers — comfortable following a problem from a model's output, through an application log, all the way down to a database query.
• Strong written and verbal communication — you'll work asynchronously with US-based teammates daily, so your design docs, pull request descriptions, and status updates need to carry context on their own.
• Ownership without hand-holding — given a problem and constraints, you scope an approach, pressure-test it with peers, and execute. You escalate early when blocked and you don't let work quietly stall.

Nice-to-haves:

• Document AI or OCR pipelines — PDF parsing, layout-aware extraction, or commercial document-extraction services.
• Infrastructure-as-code and Kubernetes-native tooling — Helm, ACK (AWS controller for K8s), Terraform, CDK, or demand-based autoscaling.
• Vector search, embeddings, and retrieval in production — semantic similarity, RAG, entity resolution, or fuzzy record matching at scale.
• Observability engineering — OpenTelemetry, Prometheus, Grafana, structured logging, or defining service level objectives that people actually act on.
• Deeper agentic AI experience — multi-agent designs, Model Context Protocol (MCP) or comparable tool interfaces, agent memory and context management, or evaluating agent trajectories rather than just final answers.
• High-throughput data or document processing at scale, and the performance and cost work that comes with it.
• AI evaluation and observability tooling — LLM tracing, prompt versioning and experimentation platforms, or LLM-as-judge scoring done rigorously enough to trust.
• Monorepo tooling and managing multiple deployable services from a shared codebase.
• Data warehouse integration — building pipelines that feed analytics platforms such as Snowflake.