Urgent openings For Golang Engineers - Immediate Joiner

We are looking for Golang Engineers who has deep technical command over the language, its runtime, and its ecosystem. This role is hands-on you will write production-grade Go code, solve complex technical problems across teams, and act as the go-to person for all things Go within the organization.

Role: Golang Engineeer

Experience : 3 to 8 Years

Location : Siruseri, Chennai

Notice Period : Immediate Joiners to 30 Days

Role & responsibilities

• Write clean, idiomatic, and performant Go code for enterprise-grade systems.
• Serve as the Go subject matter expert across engineering teams provide guidance, unblock developers, and help resolve complex Go-related issues.
• Use AI-assisted development tools (Claude, Claude Code) effectively to generate boilerplate code, prototype solutions, debug issues, write tests, and produce technical documentation faster.
• Coach and enable team members on how to use AI tools productively for Go development workflows.
• Conduct deep-dive debugging of production issues including memory leaks, goroutine leaks, deadlocks, race conditions, and performance bottlenecks.
• Review code with a focus on correctness, performance, readability, and adherence to Go idioms and conventions.
• Design and implement internal libraries, shared packages, and reusable middleware that other teams consume.
• Define and enforce Go coding standards, project structure conventions, and best practices across the organization.
• Contribute to architectural decisions related to concurrency models, API design patterns, error handling strategies, and dependency management.

Required Technical Expertise

Go Language Mastery (Must Have)

• 5+ years of professional Go development with deep understanding of the language specification.
• Expert-level knowledge of Gos type system including interfaces, type assertions, type switches, generics (Go 1.18+), and embedding.
• Deep understanding of Go’s concurrency model — goroutines, channels, select statements, sync primitives (Mutex, RWMutex, WaitGroup, Once, Pool), and the context package for cancellation and timeout propagation.
• Strong grasp of Go’s memory model — stack vs heap allocation, escape analysis, garbage collector behavior and tuning, and how to write GC-friendly code.
• Proficiency with Go’s standard library — net/http, encoding/json, io, bufio, os, fmt, testing, reflect, unsafe (when justified), and embed.
• Experience with error handling patterns — custom error types, error wrapping and unwrapping (errors.Is, errors.As), sentinel errors, and structured error strategies for large codebases.
• Ability to write and optimize Go tests — table-driven tests, subtests, test fixtures, mocks, fuzz testing (Go 1.18+), and benchmark tests with proper profiling.

Runtime and Performance (Must Have)

• Hands-on experience with Go profiling tools — pprof (CPU, memory, goroutine, block profiles), trace tool, and runtime metrics.
• Ability to identify and resolve performance issues including excessive allocations, contention on locks, channel bottlenecks, and inefficient serialization/deserialization.
• Understanding of compiler optimizations — inlining, bounds check elimination, and how to write code that the compiler can optimize effectively.
• Experience with race detector usage and writing race-free concurrent code.

API and System Design (Must Have)

• Experience designing and building RESTful APIs with clean separation of concerns — handlers, services, repositories, and middleware layers.
• Strong understanding of HTTP internals in Go — server lifecycle, connection pooling, timeouts (read, write, idle, handler), graceful shutdown, and middleware chaining.
• Experience with gRPC and Protocol Buffers for inter-service communication.
• Knowledge of serialization formats — JSON (custom marshalers/unmarshalers), Protocol Buffers, MessagePack, and when to use each.

Code Architecture (Must Have)

• Ability to structure Go projects following established patterns — flat structure for small services, domain-driven layout for larger applications.
• Experience designing interfaces for testability and decoupling — keeping interfaces small, defining them at the consumer side, and using dependency injection without frameworks.
• Knowledge of common Go design patterns — functional options, builder pattern, middleware c