Golang Backend Engineer

Callease AI; Ahmedabad District; On-site; INR 1,200,000 - 1,900,000; Full time

Job summary

Callease AI in India is looking for an experienced Go backend engineer to own real-time, latency-sensitive services. You will design and maintain streaming data pipelines, WebSocket-based interactions, and high-throughput endpoints in a distributed microservices environment.

The role emphasizes ownership: write tests, ensure production reliability, and optimize memory and throughput. You will work with Docker and Kubernetes, collaborate with leadership, and ship robust code that scales under

Qualifications

• Go (Golang) proficiency with production-grade tooling.
• Experience with concurrent, distributed backend systems.
• Strong emphasis on testing and reliability.
• Ownership mindset and accountability for deployed code.
• Familiarity with modern CI/CD workflows.

Responsibilities

• Build real-time backend systems, streaming data pipelines, WebSockets, async processing, low-latency services.
• Develop concurrent and distributed architectures with goroutines, channels, worker pools.
• Design queue-based workflows, retry logic, failure recovery, orchestration pipelines.
• Work with PostgreSQL and Redis for high-write workloads and state transitions.
• Create and maintain API and integration layers (REST/gRPC) and internal services.
• Profile, optimize memory, tune throughput, and reduce latency; contribute to deployments and observability on Docker/Kubernetes.

Skills

Go (Golang)

Concurrency-heavy backend systems

Unit testing

Production reliability

Ownership & accountability

Tools

Docker

PostgreSQL

Redis

Git, CI/CD

Linux

WebSockets

Kubernetes

REST/gRPC

Job description

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