Software Engineer

About us

Deepvue.ai builds identity, risk, fraud, and compliance infrastructure on India's digital public infrastructure. Lenders, NBFCs, fintechs, and internet companies use us to verify customers and businesses at scale.

We're revenue-generating, backed by 100X.VC, and deliberately lean. We're expanding beyond verification into AI for risk and decisioning products for financial services.

The role

We move fast on new ideas. Someone takes a problem from nothing to a working prototype, we put it in front of customers, and then it needs to become a real product — extended, hardened, configurable, and built out across every case a customer actually has.

You'd start on that second half, because it's how you learn the systems and the customers fastest. Six months in, once you have that, you'd be starting things yourself too — taking a problem from zero rather than only building it out.

What that looks like day to day

• Building out new product surfaces from prototype to production
• Customer-specific configurations and variants — the same components assembled differently for different requirements
• Extending the existing API platform, and the APIs behind our dashboards and customer-facing interfaces
• Building and scaling AI/ML and GenAI pipelines from experimental workflows into production systems
• Working across the stack, from backend services to product SDKs, to get AI features into user-facing applications
• Owning critical product components end to end — you're accountable for them being robust in production, not just merged
• Increasingly, your own problems to take from nothing

The scope widens as we ship. Whatever gets validated next lands with you, so this isn't a fixed queue of work — it grows with the company, and so does what you own.

You'll ship a lot. That's the point of the role.

Our stack

Python (Django, FastAPI) across most of the platform, with some services in Go. TypeScript on the front end. MySQL, Postgres, MongoDB, Docker, AWS. On the AI side, LLM APIs and agentic frameworks, with vector stores and retrieval where the problem calls for it. CI/CD and an observability stack — you'll instrument your own services.

What we actually need from you

• Strong Python, with Django or FastAPI in production. That's what we'll expect you to be fluent in on day one. Expect to pick up Go alongside it — some of what you'll build lives there
  
• Enough TypeScript to build the interface your API feeds. Working forms, tables and flows against a component library. You're not designing, and we're not expecting polish
  
• AWS, hands-on. You'll deploy your own work, instrument it, and be the one who notices when it breaks. Containers, load balancing, CI/CD, monitoring — not someone waiting on a platform team, because there isn't one
  
• A programming foundation beyond the main stack. You can reach for Node or shell to build an automation workflow, an integration script or a sample app when the job needs one
  
• An instinct for scalability, reliability and fault tolerance. Our customers are lenders and NBFCs — when something degrades, it degrades on someone's loan application
  

Nice to have

• Prior Go experience — it's a language you'll pick up in a few weeks either way
  
• Orchestrating third-party APIs — retries, fallbacks, rate limits, and keeping things working when an upstream provider doesn't
  
• Hands-on work with LLMs or agentic frameworks. If you've run an AI agent, a RAG setup or an MCP-based system in production rather than in a demo, say so — prototypes are everywhere right now, and having kept one alive under real traffic counts for a lot more. If you haven't, being strong on Python, AWS and API orchestration will get you there quickly enough

What we're looking for

• 1–2 years building and shipping production software
  
• You like shipping. The tenth version of something needs to work and be maintainable. It does not need to be beautiful
  
• Comfortable extending, ambitious about starting. Early on you'll read what exists, understand the shape, and extend it — an instinct to rebuild everything first will get in the way. But we're not looking for someone who only follows a template either, because within six months you'll be starting things yourself
  
• Product sense. Everything you build encodes something a real customer is trying to do. Understanding that is how you get it right the first time
  
• You ask good questions once, then focus. Small team, limited review capacity
  
• Use AI tools freely — own the decisions yourself. We expect you to ship faster with them, and we use them too. What we won't accept is code you can't explain, or an architecture you didn't choose. If you can't say why something works the way it does, it isn't finished
  

Being straight with you

Small team, Bangalore-based with two days a week in the office, no dedicated QA or DevOps. You'd be working directly alongside the engineer who built most of what exists, and with a founder.

Early on, a lot of this work is building the next version of something that already exists. We think that's interesting — it's how a prototype becomes a product people pay for — and it's the fastest way to learn our systems. But it does mean the first few months aren't greenfield, and you should be fine with that.

Compensation

₹12–15 lakh, depending on what you've built before and how you do through the process — not years on a CV.

Process

1. A call with the founder — the business, the role, your questions
   
2. A take-home assignment — roughly 4–8 hours of focused work. A small API, a simple hosted form, a data write. We want working software, not a design document
   
3. A session with our engineer — we walk through your assignment, then show you something real we've built and ask how you'd extend it
   
4. Final decision — a conversation on the offer, and we answer whatever's still open for you
   

We move fast and we'll tell you where you stand at every stage.

Apply

Tell us something you've built and shipped, here(https://forms.gle/gAntgLBkDPifLydA9)