Principal Engineer (PMTS) – Backend & Platform

Ecolibrium; Bengaluru Urban; On-site; INR 4,000,000 - 7,000,000; Full time

Job summary

Ecolibrium Bengaluru is seeking a Principal Member of Technical Staff to own backend services powering our energy and IoT platform. This backend-first role requires writing production code weekly, shaping high-throughput distributed systems on AWS and Kubernetes, and delivering production-ready services with strong DevOps discipline.

You will design APIs, own incident resolution, mentor engineers, and champion AI-assisted development with Claude Code and Cursor, while balancing performance,

Qualifications

• 8+ years of software engineering experience, backend focus.
• Hands-on production experience with distributed systems.
• Strong API design and data modelling skills.
• Experience with AWS and container platforms.
• Experience with AI tooling integration is a plus.

Responsibilities

• Design, build, and ship production-grade backend services in Java, Spring Boot, Python, and Go.
• Own end-to-end service performance: profiling, caching, memory management.
• Set standards for testing, code reviews, and production readiness.
• Design event-driven systems using Kafka, MQTT and Flink for IoT telemetry.
• Operate AWS infrastructure and manage CI/CD pipelines.

Skills

Java/Spring Boot

Python

Go

API design

Distributed systems

AWS

Docker

Kubernetes

Tools

Kafka

PostgreSQL

Redis

Terraform

OpenTelemetry

Job description

We are looking for a Principal Member of Technical Staff (PMTS) to design, build and own the backend services and distributed systems that power our energy and IoT platform. This is a backend-first role: the PMTS will write production code every week, shape the architecture of high-throughput, event-driven services, and take those services all the way to production on AWS and Kubernetes.

This is a deeply hands-on senior individual contributor role. It requires very strong backend engineering, because that is where most of the work is; strong distributed systems depth, because our platform processes real-time telemetry at scale; and strong hands-on DevOps capability with AWS, Docker and Kubernetes, because engineers here own what they build through to production rather than handing it over. This is an AI-native engineering environment: AI coding agents such as Claude Code and Cursor are part of the daily workflow, and the PMTS will set the standard for how AI-assisted changes are reviewed. The role requires 8+ years of relevant experience.

THE WORK

Key Responsibilities

• Design, build and ship production-grade backend services in Java, Spring Boot, Python and Go, writing a significant share of the code yourself.
• Design APIs, data models and service contracts with versioning, failure semantics and scaling paths considered up front.
• Own performance of services end to end: profiling, query optimisation, caching, connection management and memory behaviour.
• Set and enforce standards for code quality, automated testing (unit, integration and contract) and code review.
• Modernise legacy services incrementally without disrupting production.
• Choose the right technology for the problem rather than defaulting to a familiar stack.

Distributed Systems & Data

• Design and build event-driven and streaming systems on Kafka, MQTT and Apache Flink for high-throughput IoT telemetry.
• Make deliberate trade-offs on consistency, ordering, partitioning, idempotency and delivery guarantees.
• Build for failure: retries with backoff, circuit breaking, backpressure, graceful degradation and safe replay.
• Design data storage across PostgreSQL, Redis and time-series databases for scale, retention and query patterns.
• Debug hard problems across service, database, messaging and network layers.
• Containerise services with Docker and own their deployment on Kubernetes, including manifests, Helm, autoscaling, resource limits and health checks.
• Design and operate AWS infrastructure for the services you build, with ownership of architecture, security and cost.
• Build and maintain CI/CD pipelines with automated testing, safe database migrations and rollback.
• Write infrastructure as code (Terraform or equivalent) held to the same review and versioning standards as application code.
• Instrument services with metrics, structured logs and tracing so problems are visible before customers report them.
• Own what you ship in production, including incident resolution and fixing root causes in code.

Architecture & Technical Leadership

• Own architecture for backend services and set technical direction through design reviews, RFCs and working code rather than mandate.
• Take ambiguous problems from definition through design, implementation and testing to production.
• Document consequential technical decisions, including trade-offs and the options deliberately rejected.
• Mentor engineers on backend design, distributed systems and production ownership, and unblock teams on hard technical problems.
• Use Claude Code, Cursor and equivalent AI coding agents in daily work, and define the review standards for AI-assisted changes.

THE ENVIRONMENT

Technology Environment

• Messaging & Streaming: Kafka, MQTT, Apache Flink and event-driven architectures.
• Data: PostgreSQL, Redis and time-series databases.
• Cloud: AWS.
• Infrastructure: Docker, Kubernetes, Helm and Terraform.
• CI/CD: GitHub Actions or equivalent modern CI/CD tooling.
• Observability: Prometheus, Grafana, OpenTelemetry and Sentry.
• APIs & Contracts: REST, OpenAPI and AsyncAPI.
• Frontend: React and TypeScript (working knowledge).
• AI Tooling: Claude Code, Cursor and LLM APIs.

WHAT WE'RE LOOKING FOR

Qualifications & Experience

• 8+ years of software engineering experience, the majority in hands-on backend development of production systems.
• Deep expertise in Java/Spring Boot or Python (Django/FastAPI), writing production-quality code every week rather than only reviewing it.
• Strong API design, data modelling and SQL skills, including schema and query optimisation.
• Solid testing discipline, with unit, integration and contract tests as part of normal delivery.
• Proven track record designing, building and running distributed systems in production at scale.
• Hands-on experience with Kafka or equivalent messaging and event-driven architecture.
• Strong grasp of concurrency, consistency, partitioning, idempotency and failure handling.
• Exceptional debugging ability across service, database, messaging and network layers.
• Hands-on production experience on AWS across compute, networking, storage, managed databases and IAM.
• Strong Docker fundamentals and hands-on Kubernetes experience deploying, scaling and troubleshooting services in production.
• CI/CD pipelines and infrastructure as code built and maintained first-hand rather than inherited.
• Practical observability experience with metrics, logging, tracing and alerting.

Essential: Leadership & Ways of Working

• Track record of technical influence beyond personal output: standards adopted, teams unblocked and engineers levelled up.
• Ability to work independently with ambiguous requirements and bring clarity to others.
• Strong written communication across design documents, RFCs, post-mortems and runbooks.
• Bias towards owning outcomes rather than tickets, and towards fixing causes rather than symptoms.
• Fluent use of Claude Code, Cursor or equivalent AI development tools in daily engineering work.
• Apache Flink, MQTT or time-series databases (ClickHouse, InfluxDB) at scale.
• React and TypeScript working knowledge.
• Experience building LLM-powered or Agentic AI features in production.
• Experience in high-velocity product or startup environments.