Software Development Engineer III (SDE 3)

Professional networking has barely moved in twenty years. Enterprise sales software has moved, but mostly by adding more dashboards to the same motion. OrbitShift was built on a different belief: that a multi-agent AI system, given the right architecture, can do the work a GTM team actually needs done, from account insights and RFP responses to targeted nudges and sales content.

Backed by Peak XV (formerly Sequoia Capital) and Stellaris Venture Partners, OrbitShift is three years in, fifty to one hundred people strong, with a team drawn from Amazon, McKinsey, IIT, and Stanford. The engineering culture runs on real autonomy: you own how you build, not just what you build.

An AI-native platform for enterprise sales. Built in Bengaluru, for the world.

OrbitShift's multi-agent AI platform is in the hands of enterprise GTM teams and growing fast. Clients are scaling up, the surface area is expanding, and the platform needs engineers who can own large, ambiguous problems end-to-end: from architecture through deployment and observability.

As SDE 3, you'll sit at the intersection of distributed systems and applied AI infrastructure. You'll own client-facing features and core platform components, drive architecture and low-level design with equal sharpness, and act as a technical multiplier for the engineers around you. The work is hands-on and consequential: what you design today shapes how the platform evolves as load grows and requirements shift.

Architecture across services. Design multi-service systems with clear ownership boundaries, making strong choices on storage, partitioning, caching, sync vs. async paths, and API contracts.

Low-level design depth. Own the LLD bar for larger, less-bounded problems: clean modelling, justified pattern choices, plugin and registry-style extensibility where it earns its place, and deliberate handling of concurrency, thread-safety, and performance under load.

Client-facing feature delivery. Take client requirements end-to-end, from design through deployment and observability, writing production-quality code for core platform components.

Trade-off and reliability conversations. Lead deep trade-off analysis on consistency models, cost vs. latency, SLO definition, failure modes, recovery paths, and capacity planning, unprompted.

The AI platform layer. Contribute to multi-agent orchestration, reasoning pipelines, memory systems, tool-use frameworks, and evaluation harnesses that catch regressions before they reach production.

Technical leadership. Set engineering standards, lead design reviews, mentor mid- and junior engineers, and represent the team in cross-functional discussions with product and research.

You're equally sharp at HLD and LLD. You can own an architecture conversation and then go three levels deep on the low-level design without losing precision at either layer.

You've owned systems end-to-end in a B2B SaaS or enterprise product environment. You understand how enterprise software behaves under real client load, and you've shipped for it.

You come from a product company or AI startup. Backgrounds from places like Eightfold.ai, Pixis.ai, Haptic.ai, Dream11, or similar B2B-first engineering orgs tend to produce the right instincts here.

Distributed systems are your native language. Strong command of microservices, cloud-native architectures on AWS, and sound trade-off judgment under ambiguity.

You use AI coding tools as a daily productivity layer. Claude Code, Cursor, or similar tools are part of how you work, not something you're evaluating.

Pattern understanding over tool familiarity. You can ramp on a new stack quickly because you understand the underlying patterns: vector databases, embedding pipelines, LLM orchestration frameworks.

You own things fast. In the first few weeks, you're already taking on architecture and feature design, not waiting to be handed a scope.

You apply SOLID and design patterns with judgment. You know when to abstract and when not to, and you can justify the call.

Own the problem, not just the ticket. You take the full surface: design, delivery, observability, and the conversation when something breaks.

Go deep before you go broad. Low-level design is not a formality here. Model cleanly, justify your pattern choices against alternatives, and handle the hard concurrency and performance cases deliberately.

Drive trade-off conversations unprompted. Reliability, consistency models, cost vs. latency: you raise these before someone asks.

Stay hands-on in code. Senior here means you're still writing production-quality code for core components, not just reviewing others' work.

Evaluate emerging tools with rigour. You assess frameworks like LangChain, LlamaIndex, and ADK against real production requirements before bringing them in.

Multiply the engineers around you. Design reviews, mentorship, and engineering standards are part of the job, not extras.

Forty-five to sixty-five lakh per year, with room for the right person, plus meaningful seed-stage equity. Fully remote, with the flexibility to work from anywhere. A founding-tier engineering seat on a platform backed by Peak XV and Stellaris, at the moment it's scaling hardest.