API Engineer

Role & responsibilities

Senior C++/PostgreSQL API Engineer (Ultra-Low Latency Trading)

Location: Hybrid/Remote

Type: Full-time

Team: Core Trading Platform

What youll do

Design and build ultra-low-latency C++ services for order routing, market data, and risk checks (targets: p99 500s per hop on LAN; end-to-end trade path p99 3–5ms depending on venue).

Implement high-performance APIs (gRPC/Protobuf and WebSocket/REST where needed) exposing trading, positions, and account data backed by PostgreSQL.

Engineer lock-free / wait-free components, efficient memory management (arena allocators, object pools), and NUMA-aware data structures.

Build and tune PostgreSQL for low-latency reads/writes: schema design for time-series/partitioned tables, prepared statements, libpq/libpqxx, PgBouncer pooling, logical replication, and LISTEN/NOTIFY for eventing.

Use Redis (Cluster) for hot paths: price cache, order state cache, Streams/PubSub, Lua scripts for atomic ops; set correct persistence (RDB/AOF) policies per service.

Optimize network I/O (epoll/kqueue, io_uring), batching, zero-copy, and back-pressure. Explore kernel-bypass/RDMA/DPDK where justified.

Create observable systems: high-resolution latency histograms, tracing, and metrics (Prometheus/Grafana); integrate eBPF or perf for hotspots.

Ensure resilience & correctness: deterministic simulations, soak/chaos tests, replay tools from pcap/logs, and circuit-breakers/timeouts.

Collaborate with quant, infra, and frontend teams; participate in on-call rotation for production trading hours.

Tech you’ll use

C++20/23, STL, atomics, chrono, coroutines; Boost.Asio/Folly/absl (as needed); CMake; clang/gcc; sanitizers; valgrind; perf/eBPF; flamegraphs.

PostgreSQL 14+, libpq/libpqxx, PgBouncer, partitioning, BRIN/B-tree indexes, COPY, logical replication/decoding.

Redis (Cluster/Sentinel), Streams, Pub/Sub, Lua, pipelining.

Protocols: FIX (nice-to-have), exchange/venue native, Protobuf/gRPC, WebSocket/HTTP/2.

Tooling: Git, CI/CD, Docker/Podman; Kubernetes (nice-to-have).

Minimum qualifications

5+ years with modern C++ in production, including low-latency and concurrency (lock-free, ring buffers, SPSC/MPSC queues).

Deep knowledge of Linux systems: CPU pinning, NUMA, cache lines/false sharing, NIC tuning, kernel params.

Strong PostgreSQL experience: performance tuning (autovacuum, WAL, checkpoint, shared_buffers), query planning, prepared/batched I/O.

Production Redis usage for latency-critical paths (pipelining, key design, eviction strategy).

Profiling + benchmarking mindset; you’ve moved p99s not just averages.

Nice-to-have

Market data/order-book engineering (price-time priority, gap handling, snapshot+incremental models).

Risk/limits engines (per-account, per-symbol throttles), idempotent order handling.

Experience with FIX, Betfair/sportsbook APIs or crypto exchange APIs.

Hardware timestamping/PTP, NIC offloads; DPDK/Netmap; io_uring; RDMA.

Kafka/NATS/Chronicle Queue; columnar/time-series DBs (ClickHouse, Timescale).

Success metrics (first 90–180 days)

Reduce critical service p99 latency by 30%; eliminate GC/allocator spikes.

Achieve zero order-path correctness defects in production releases.

Establish automated latency SLO dashboards and regression benchmarks in CI.

Deliver a new C++ trading API with Postgres+Redis backing that sustains >50k msgs/sec with p99 under target on staging hardware.

Sample problems you’ll tackle

Re-architect order ingress with batched syscalls + lock-free queues to cut tail latency.

Redesign Postgres schemas to partition by (symbol, day); add BRIN for time scans; switch to prepared multi-row INSERTs.

Introduce Redis Streams for fast, ordered state fan-out with consumer groups.

Add exact-once semantics across C++ Redis Postgres using idempotency keys and outbox/inbox patterns.