Backend Developer - Go

Neo Wealth and Asset Management; Bengaluru; On-site; INR 1,800,000 - 3,200,000; Full time

Job summary

Neo Wealth and Asset Management is building Mor Platform, a high-throughput in-house trading system in Bengaluru. You will design latency-critical Go services and own end-to-end deployment and production behavior.

Join a small, senior team to ship real-time market data streaming, order matching, and analytics components with a focus on correctness, performance, and operability in a cloud-native environment.

Qualifications

• 3+ years backend development in production with Go.
• Strong concurrency: race conditions, memory visibility, backpressure.
• Solid networking fundamentals: TCP/UDP, WebSocket, TLS.
• Deployment experience: Docker, CI/CD, cloud (AWS).
• Observability: metrics, logs, traces.
• Relational DBs and query performance.
• Market data or low-latency domain experience.
• Messaging systems: NATS, Kafka.
• Multicast/UDP handling and binary parsing.
• Protobuf or binary serialization.
• Time-series modelling (TimescaleDB).
• Kubernetes / infrastructure-as-code.

Responsibilities

• Design latency-sensitive Go services with microsecond hot paths.
• Write correct concurrent code: goroutines, channels, locks.
• Profile and optimise with pprof and production telemetry.
• Own deployment: containers, CI/CD, rollout/rollback.
• Build recovery paths that do not require human intervention.
• Participate in design reviews and document trade-offs.

Skills

Go

Concurrency

Networking

Docker

CI/CD

Observability

Relational DBs

Messaging systems

UDP multicast

Protobuf

Kubernetes

TimescaleDB

Education

Bachelor's degree in CS

Tools

NATS

Kafka

TimescaleDB

Job description

You will work on Mor Platform, our in-house trading platform built around real-time market data streams and real time trading infrastructure. You will design and develop latency-critical, scalable applications from scratch.

You will own services end to end — design, implementation, deployment and production behaviour. We are a small, senior team, so there is no layer between you and the decisions that matter.

What you'll work on

• Live Price Feed — a high-concurrency WebSocket service streaming LTP and full quotes to mobile apps, built on an event-loop model rather than goroutine-per-connection.
• Tracker — a real-time alerting engine evaluating user-defined conditions on stocks, F&O contracts and multi-leg strategies, with a sub-500 ms p99 tick-to-alert budget.
• Multicast Parser — decoding raw exchange multicast (market watch, depth, OI, market status, DPR) across four segments and publishing normalised events onto the message bus.
• Charts — tick by tick storage and 1m / 1h / 1d / 1w candle aggregation over a time-series store.
• Search — low-latency instrument search across the full tradable universe, rebuilt daily.
• Trading Engine — a low-latency, fault-tolerant and scalable trading engine.

What you'll do

• Design and build latency-sensitive Go services where the hot path is measured in microseconds, not milliseconds.
• Write correct concurrent code: goroutine lifecycle management, channel and lock discipline, atomics, backpressure, and avoiding O(subscribers) work per tick.
• Profile and optimise real workloads — allocation pressure, GC behaviour, lock contention, serialization cost — using pprof and production telemetry rather than guesswork.
• Own deployment and operability: containers, CI/CD, rollout and rollback, structured logging, metrics and tracing.
• Reason about failure explicitly — what happens on a bus outage, a node restart, a bad message, or an exchange reconnect — and build recovery paths that don't require a human.
• Participate in design reviews where alternatives are argued on merit and trade-offs are written down.

What we're looking for

Required

• 3+ years building backend services in production, with meaningful depth in Go.
• Strong, practical grasp of concurrency — race conditions, memory visibility, channel semantics, context cancellation, worker pools and backpressure.
• Solid networking fundamentals: TCP/UDP, sockets, WebSocket, HTTP semantics, TLS, connection lifecycle, and how these behave under load.
• Hands-on deployment experience — Docker, CI/CD pipelines, and running services in a cloud environment (AWS preferred).
• Observability as a habit: you instrument what you build and can debug a live production issue from metrics, logs and traces.
• Working knowledge of relational databases and query performance.
• Experience with market data, trading systems, or any high-throughput low-latency domain (telemetry, gaming, streaming).
• Exposure to NATS, Kafka, or similar messaging systems.
• Multicast / UDP protocol handling and binary parsing.
• Protobuf or other binary serialization formats.
• PostgreSQL, MongoDB, Elasticsearch, TimescaleDB, or time-series data modelling.
• ECS, Kubernetes, or infrastructure-as-code.