Golang Developer

Merge; Bengaluru; On-site; INR 3,000,000 - 6,000,000; Full time

Job summary

Merge is seeking a Senior Golang Developer to join the core architecture team in Bengaluru. You will design, build, and maintain high-throughput backend services in Go, focusing on scalable microservices, low-level design, and strong DSA skills.

The role emphasizes performance optimization, concurrency, and robust API design with REST and gRPC. You will work with distributed systems, caching, and SQL/NoSQL databases, and participate in code reviews to ensure idiomatic Go and secure, maintainable

Qualifications

• 5+ years of backend experience with a focus on Go
• Proficient in Low-Level Design (LLD) and modular architecture
• Strong Data Structures & Algorithms knowledge and problem-solving abilities
• Hands-on experience building scalable microservices in Go
• Experience with REST and gRPC APIs, and messaging systems (Kafka/RabbitMQ/NATS)
• Familiarity with caching (Redis) and SQL/NoSQL databases
• Knowledge of profiling and optimization (pprof) and Go runtime internals

Responsibilities

• Design, build, and maintain production-grade microservices in Go
• Apply SOLID principles and Clean Architecture in Go-based systems
• Optimize performance and diagnose bottlenecks using profiling tools
• Leverage Go concurrency primitives for scalable systems
• Design robust RESTful and gRPC APIs and integrate with Kafka/RabbitMQ/NATS
• Optimize database queries and indexing for SQL/NoSQL
• Lead code reviews and promote idiomatic Go practices and security

Skills

DSA problem solving

LLD design

Go backend development

Concurrency management

API design REST/gRPC

Performance optimization

Tools

Go frameworks (Gin, Echo, Fibre)

Go modules

pprof profiling

Docker

Kubernetes

Redis

PostgreSQL/MySQL

MongoDB

gRPC tooling

OpenTelemetry/Prometheus/Grafana

Job description

We are looking for a Senior Golang Developer with 5+ years of core backend engineering experience to join our core architecture team. The ideal candidate possesses exceptional Data Structures & Algorithms (DSA) problem-solving skills, deep expertise in Low-Level Design (LLD), and extensive hands-on experience building scalable, high-throughput backend services using Go.

Responsibilities:

• Architecture and Development: Design, build, and maintain production-grade microservices and distributed backend systems using Go.
• Low-Level Design (LLD): Write clean, extensible, modular, and maintainable code adhering to SOLID principles, OOP concepts (where applicable in Go design patterns), design patterns (e. g., Factory, Strategy, Builder, Decorator), and Clean Architecture principles.
• Performance Optimisation: Apply advanced Data Structures and Algorithms (DSA) to write high-efficiency, memory-optimised algorithms. Diagnose performance bottlenecks, race conditions, and memory leaks using profiling tools like pprof.
• Concurrency Management: Leverage Go's native concurrency primitives (goroutines, channels, select, sync. Mutex, sync. WaitGroup) to build efficient concurrent systems while preventing deadlocks and race conditions.
• API and System Integration: Design robust RESTful and gRPC microservices APIs, integrating with message brokers (Kafka, RabbitMQ, NATS) and caching layers (Redis).
• Data Management: Optimise complex database queries, schema designs, and indexing strategies across SQL (PostgreSQL, MySQL) and NoSQL (MongoDB) databases.
• Quality and Code Reviews: Lead technical code reviews focusing on idiomatic Go practices, maintainability, and security. Enforce unit, integration, and benchmark testing using testing, Testify, or GoMock.

Requirements:

• Data Structures and Algorithms: Strong command of core data structures (Arrays, Linked Lists, Trees, Graphs, Hash Tables, Heaps) and algorithm design strategies (Dynamic Programming, Greedy Algorithms, Graph Traversals, Sliding Window). Ability to evaluate time and space complexity ($O(n)$ analysis).
• Low-Level Design (LLD): Proven ability to model real-world business domains (e. g., Rate Limiters, Payment Gateways, In-Memory Caches, Task Schedulers, Notification Engines) using proper abstraction, interfaces, domain-driven design (DDD), and modular package structure.

Core Golang Expertise:

• 5+ years of professional backend software development with at least 3+ years of dedicated experience writing production-level Go.
• Deep understanding of Go internals: Memory allocation (Heap vs. Stack, escape analysis), Garbage Collection tuning, and runtime execution model.
• Hands-on experience with Go web frameworks (e. g., Gin, Echo, Fibre) and dependency management (go modules).

Systems and Storage:

• Proficiency with relational databases (PostgreSQL/MySQL) and writing optimised queries, transactions, and indexing.
• Hands-on experience with caching solutions (Redis) and distributed queue/event systems (Kafka, RabbitMQ, or NATS).
• Experience with API protocols: REST, gRPC, and Protocol Buffers.

Bonus Skills

• Exposure to High-Level Design (HLD) and distributed systems concepts (load balancing, circuit breakers, data partitioning, consensus protocols).
• Experience containerising services with Docker, deployment on Kubernetes, and CI/CD automation.
• Experience with observability tooling (OpenTelemetry, Prometheus, Grafana, Zap, Viper).