Principal Engineer

Zeta; Bengaluru; On-site; INR 4,200,000 - 6,000,000; Full time

Job summary

Zeta in Bengaluru seeks a Principal Engineer to own design and architecture across backend services and frontend components. You will mentor teams, shape AI-first SDLC, and drive rapid iteration while upholding reliability, security, and performance.

You will lead cross-team design reviews, establish standards, and push for scalable solutions across a modern stack with Java/Python, REST, SQL, and microservices.

Qualifications

• 8+ years in software development and delivery.

Responsibilities

• Own the architecture of backend services and frontend components, including data models and service boundaries.
• Resolve cross-cutting reliability, performance, and security concerns.
• Build platforms, reusable libraries, and utilities to accelerate the team.
• Drive end-to-end delivery from spec to shipped software with parallel agents.
• Mentor engineers and run design reviews to raise engineering standards.

Education

Engineering degree in computer science

Tools

Kafka

Cassandra/Scylla

Redis

AWS / GCP / Azure

gRPC / HTTP/2 / QUIC

Kubernetes

CI/CD pipelines

Job description

As a Principal Engineer, you will own the design and architecture of the suite and mentor engineers across teams. We are proponents of leveraging best-in-breed AI tools at every step of the engineering lifecycle: design, development, review, and testing. This requires a different engineering mindset: a lean team of senior, hands-on, AI-adept engineers, resulting in ultra-rapid iteration cycles and fast output. You will own and oversee this approach for the systems you lead, from design through to production. This is a role for a proactive, independent decision-maker who is at home reasoning from system internals up to cross-team architecture and who raises the bar for what both people and agents ship.

The core responsibilities for the job include the following:

Architecture and technical direction:

• Own the architecture of Neo's backend services and frontend components, service boundaries, and data models.
• Resolve cross-cutting reliability, performance, and security concerns.
• Build platforms, reusable libraries, and utilities that make the team faster and the codebase consistent.

Execution and delivery:

• Drive delivery end to end: turn a spec into shipped software by breaking it down, running agents in parallel to implement, and steering them to a working result.
• Own verification of the real bottleneck in an agentic workflow. Decide what "correct" means for a system and make sure what ships actually meets it before it reaches users.

AI-first SDLC harness:

• Build and improve the harness the team builds with specs, reusable skills, subagents, evals, and guardrails that let many agents work in parallel and give consistent results regardless of the underlying tool.
• Set the quality gates that agent-authored changes pass before a human reviews them, and improve them as failure modes show up.

Mentoring and raising the bar:

• Mentor engineers and run design reviews; turn what works into standards, templates, and paved roads the whole team uses.
• Spread good agent practice across the team so its leverage compounds, not just your own.

Product thinking:

• Work with the product to pin down the right problem before building scope feasibility and surface trade-offs, and push back when the cost isn't worth the outcome.
• Own outcomes, not tickets.

Requirements:

• 8+ years in software development and delivery, with a track record of architecting systems at scale.
• Production experience across a modern stack, e. g., Java / Python with REST, SQL (PostgreSQL or MySQL), messaging systems, and microservices.
• Engineering degree in computer science or equivalent.
• AI-native engineering practice: Fluent in an agentic development workflow: spec-driven delivery, running and steering coding agents, and building the harness (specs, skills, evals, and guardrails) that makes agent output reliable at the team level
• Strong language and runtime fundamentals: Deep proficiency in one or more of the languages we work in: Java, Python, TypeScript/JavaScript, and Go, including OOP and design, concurrency, memory management, and how your runtime behaves under load. Comfortable picking the right language for the job rather than defaulting to one.
• System internals: Working knowledge of processor, memory, network, and storage internals, and how to write code that exploits hardware well and avoids bottlenecks.
• Distributed systems: Fault modelling, concurrency, isolation, and consensus; time, clocks, and ordering of events; rate control and load distribution. Strong design and problem-solving instincts for performance, scalability, security, and reliability.
• Internals of core infrastructure: Hands-on with the internals of Kafka, Cassandra/Scylla, and Redis enough to troubleshoot, tune, and make sound usage decisions.
• I/O-optimized algorithms: Asynchronous and non-blocking I/O and DMA for high throughput in performance-critical paths.
• Hosting and orchestration of Kubernetes and containerised deployment of cloud-native applications.
• Low-level network protocols: Familiarity with gRPC, HTTP/2, and QUIC.
• Troubleshooting and performance: Diagnosing memory issues, GC tuning, and resource leaks to keep systems stable and efficient under load.
• Delivery engineering: Branching, building, deployment, and CI/CD practices that keep delivery fast and high-quality.
• OOAD and algorithms: Object-oriented analysis and design and efficient data structures for well-structured, maintainable, performant systems.
• Cloud: AWS / Google Cloud / Azure (OpenStack where relevant).