Lead Platform Engineer - Golang

OmneNEST Technologies; Mumbai; On-site; INR 4,000,000 - 7,000,000; Full time

Job summary

OmneNEST Technologies is seeking a Lead Golang Platform Engineer to own production reliability, performance engineering, and platform ownership. You will anchor NFR ownership, serve as escalation for backend systems, and guide architectural guardrails for distributed services built on Golang, PostgreSQL, Kafka, and Redis.

The role emphasizes production stability, latency optimization, and end-to-end observability with strong experience in incident handling and system hardening.

Qualifications

• 6-8+ years backend engineering experience.
• Strong production experience in fintech/trading/transaction-heavy systems.
• Deep expertise in Golang: concurrency patterns, context propagation, runtime behavior, and memory profiling.
• Strong Kafka production knowledge: consumer groups, rebalancing, offset handling, and lag diagnostics.
• Strong PostgreSQL performance tuning experience.
• Experience handling real production incidents in live systems.
• Proven NFR ownership.

Responsibilities

• Platform Stabilization and Production Ownership: Act as L3/L4 escalation for backend/middleware systems; lead RCA for production incidents; diagnose latency spikes; reduce firefighting; own post-incident hardening.

Skills

Golang expert

Distributed systems

Performance engineering

Incident RCA

Memory profiling

Kafka knowledge

PostgreSQL tuning

Tools

Kafka

PostgreSQL

Redis

Grafana

Kubernetes

Job description

We are looking for a Lead Golang Platform Engineer who will act as an anchor, NFR owner, distributed systems authority, production escalation point, and architecture guardrail for the backend team. This role is not feature-driven. It is about production reliability, performance engineering, and platform ownership. The core responsibilities for the job include the following:

Platform Stabilization and Production Ownership:

• Act as L3/L4 escalation for backend/middleware systems.
• Lead root cause analysis (RCA) for production incidents.
• Diagnose latency spikes, Kafka consumer lag, DB contention, and memory pressure.
• Reduce firefighting by fixing systemic issues.
• Own post-incident hardening.

Non-Functional Requirements (NFR) Ownership:

• Own and enforce: Performance benchmarks, throughput targets, and high availability standards.
• Fault tolerance and graceful degradation, backpressure handling, and resource efficiency.
• Identify and eliminate risks in latency, GC pauses, lock contention, message ordering issues, and retry storms.

Distributed Systems and Event Architecture:

• Design and stabilize systems built on Golang, PostgreSQL, Kafka, and Redis.
• Ensure correctness in consumer group balancing, offset management, idempotency design, retry strategies, dead-letter handling, event replay, and backpressure management.
• Architect and optimize: Event-driven microservices, high-throughput APIs, PIs, and concurrent workflows.

Advanced Data and Real-Time Systems:

• Optimize SQL query performance under load.
• Improve indexing, partitioning, and connection pooling.
• Design Redis caching strategies for low latency.
• Work with OLAP systems (ClickHouse + Grafana).
• Optional exposure to distributed databases (CockroachDB).

Productization and Rule-Driven Architecture:

• Architect configurable, rule-driven workflows.
• Enable admin-driven client workflow customization.
• Implement high-performance in-memory rule evaluation.
• Prevent business logic from becoming hardcoded chaos.

Observability and Release Hygiene:

• Improve logging, tracing, and metrics across services.
• Define actionable dashboards (Prometheus / Grafana).
• Improve release discipline, rollback strategies, and versioning.
• Ensure dev/staging/prod parity.

Vendor Transition and Codebase Ownership:

• Lead structured knowledge transfer from external vendors.
• Take ownership of legacy codebases without destabilizing production.
• Identify high-risk components and stabilize incrementally.
• Establish backend engineering standards.

Team Enablement:

• Mentor 3-5-year engineers.
• Teach production debugging.
• Guide distributed systems thinking.
• Raise code quality standards.
• Act as a technical anchor (not a people manager initially).

Requirements:

• 6-8+ years of backend engineering.
• Strong production experience in fintech/trading/transaction-heavy systems.
• Deep expertise in Golang: Concurrency patterns, context propagation, runtime behavior, and memory profiling.
• Strong Kafka production knowledge: Consumer groups, rebalancing, offset handling, and lag diagnostics.
• Strong PostgreSQL performance tuning experience.
• Experience handling real production incidents in live systems.
• Proven NFR ownership.

Strongly Preferred:

• Experience in low-latency trading environments.
• Kubernetes production exposure.
• Redis performance optimization.
• WebSockets / streaming systems.
• Exchange-integrated or regulated systems.
• Vendor-built system takeover experience.