Golang Backend Engineer

The work

We run latency-sensitive backend systems in production every day. A slow streaming pipeline breaks real-time interactions. A failed event chain means customer actions never complete. A bad deploy or untested edge case becomes a production incident instantly. That's the kind of system you'll be building.

Concretely, you'll work on

• Real-time backend systems, streaming data pipelines, Web Sockets, async processing, low-latency services
• Concurrent and distributed systems, goroutines, channels, worker pools, event-driven architectures
• Queue-based workflows, long-running async jobs, retries, failure recovery, orchestration pipelines
• High-write infrastructure, events, logs, state transitions, audit systems across PostgreSQL and Redis
• API and integration layers, REST, gRPC, internal services, third-party integrations
• Performance-sensitive services, profiling, memory optimization, throughput tuning, latency reduction
• Deployments, observability, and production debugging on Docker and Kubernetes

The stack - non-negotiable in production

• Go (Golang)
• Concurrency-heavy backend systems
• PostgreSQL and/or Redis
• Docker
• Git, CI/CD
• Unit testing and production-grade code ownership

Must have used, depth flexible

• Web Sockets, streaming systems, or event-driven architectures
• Queues - Kafka, RabbitMQ, NATS, BullMQ, or similar
• REST APIs and/or gRPC
• Linux-based development environments
• Microservices or service-oriented architectures

You'll be exceptional here if you've also done

• Real-time systems or low-latency infrastructure
• Audio/video pipelines or streaming workloads
• Distributed tracing, metrics, structured logging
• Load testing and performance optimization
• Kubernetes and production infra debugging
• AI infrastructure or inference pipelines

We value execution and ownership over years alone. Someone who has spent two years deeply building and debugging production systems is more valuable to us than someone with longer experience on low-scale internal tooling.

Engineering expectations

• You own the code you push
• Every feature and bug fix must be tested before merge
• You write unit tests and validate edge cases yourself
• You are responsible for production reliability of your code
• Fast execution matters, but reliability matters equally
• We expect clean code, code reviews, debugging discipline, and accountability
• We prefer engineers who proactively identify problems instead of waiting for tickets

How we work

• You'll work directly with engineering leadership and the founding team
• We ship fast and iterate aggressively
• We expect engineers to test their own work thoroughly
• We discuss production incidents openly and fix root causes, not symptoms
• Ownership matters more than process theater
• Tooling is still evolving - you'll often build systems from scratch instead of plugging into mature internal platforms