Lead Engineer

OmneNEST Technologies; Mumbai; On-site; INR 3,500,000 - 6,500,000; Full time

Job summary

OmneNEST Technologies is seeking a Lead Golang Platform Engineer to drive production reliability for mission-critical trading platforms. You will own non-functional requirements, manage latency, backpressure, and incident response across distributed systems.

Responsibilities cover stabilisation, RCA, architecture guardrails, and platform ownership. You will mentor engineers and help design high-throughput, low-latency backends using Golang, PostgreSQL, Kafka, and Redis.

Qualifications

• 6–8+ years of backend engineering experience in fintech or trading.
• Deep expertise in Golang, including concurrency and memory profiling.
• Strong production know-how for Kafka, consumer groups and lag diagnostics.
• Proven PostgreSQL performance tuning and query optimization.
• Experience owning non-functional requirements and incident management.

Responsibilities

• Act as L3/L4 escalation for backend/middleware systems.
• Lead root cause analyses for production incidents.
• Diagnose latency, Kafka lag, DB contention, and memory pressure.
• Implement backpressure handling and resource efficiency.
• Design and stabilize event-driven microservices and APIs.
• Mentor engineers and raise code quality standards.

Skills

Golang proficiency

Concurrency patterns

Context propagation

Memory profiling

Kafka knowledge

PostgreSQL tuning

Live incident handling

NFR ownership

Tools

Kubernetes

Redis

PostgreSQL

Prometheus

Grafana

Job description

We are building and stabilising mission-critical trading and capital markets platforms handling real-time market data, transactions, portfolio systems, and enterprise integrations.

We are looking for a Lead Golang Platform Engineer who will act as:

• Stabilization anchor
• NFR owner
• Distributed systems authority
• Production escalation point
• Architecture guardrail for the backend team
• This role is not feature-driven.
• It is about production reliability, performance engineering, and platform ownership.

The candidate will have responsibilities across the following functions:

Platform Stabilisation 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
• High availability standards

Fault tolerance and graceful degradation

• Backpressure handling
• Resource efficiency

Identify and eliminate risks in

• Latency
• GC pauses
• Lock contention
• Message ordering issues
• Retry storms

Distributed Systems and Event Architecture

Design and stabilise systems built on:

• Golang
• PostgreSQL
• Kafka
• Redis

Ensure correctness in

• Consumer group balancing
• Offset management
• Idempotency design
• Retry strategiesDead-letter handling
• Event replay
• Backpressure management

Architect and optimise

• Event-driven microservices
• High-throughput APIs
• Concurrent workflows

Advanced Data and Real-Time Systems

• Optimise 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).

Productisation 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 destabilising production.
• Identify high-risk components and stabilise 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 technical anchor (not 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 behaviour, Memory profiling.
• Strong Kafka production knowledge: Consumer groups, Rebalancing, Offset handling, 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 optimisation.
• WebSockets / streaming systems.
• Exchange-integrated or regulated systems.
• Vendor-built system takeover experience.

Who This Role Is For

This role is for someone who:

• Stays calm during production incidents
• Thinks in distributed systems, not endpoints
• Can read messy legacy code and stabilise it
• Understands performance at the runtime level
• Wants to own platform reliability
• If you want to only build features, this role is not for you.
• If you want to own the stability of capital markets infrastructure, it is.