Job Description

Role: Golang Backend Engineer (with React exposure)

Experience:

5-8 years?|?

Allocation:

~70% Go / ~30% ReactJS?|?

Start:

Able to contribute to production within

week 1

of onboarding

1) Mandatory Requirements (Shortlist only if ALL are met)

Experience:

5-8 years professional software development; recent, hands-on

Golang

in production.

Production track record:

Has

built, deployed, and supported live systems

(not POCs only).

Scalable systems exposure:

Event-driven

microservices

that run at scale (throughput/concurrency).

Reasoning & math:

Can quickly translate business rules into code (e.g., compute

GST 28% on 100

).

Rapid ramp-up:

Can

ship to production within 1 week

of onboarding (env setup, first ticket, release).

Communication:

Can

clearly explain

own architecture, trade-offs, and contribution.

Coding quality:

Smart,

idiomatic Go

(clean design, tests, error handling, performance awareness).

Event-driven architecture:

Kafka/

SQS/SNS

, idempotency, retries, dead-lettering.

gRPC:

Protobuf contracts, versioning/backward compatibility, interceptors (auth/logging).

Data:

Strong

DynamoDB

(modeling, partitions/GSIs/LSIs, capacity, pagination, consistency). Bonus if familiar with

Postgres

basics (ALTER, indexing, replication concepts).

Security:

OAuth 2.0, JWT flows.

Cloud:

AWS with

Lambdas

& serverless patterns.2) Frontend Requirement (30% of the role)

ReactJS ? 1 year

hands-on. Comfortable

re-using existing components

, API integration, basic state patterns.
3) Nice-to-Haves (Plus)

AI coding tools

exposure (e.g., Copilot/Codex/Sonnet/Cursor) with

responsible use

--candidate has used these to accelerate

70-80%

of a feature while maintaining code quality.

Terraform & deployment

knowledge (CI/CD, environment promotion).
4) Topics to Vet (Conceptual depth over theory)

Go:

concurrency (goroutines, channels, contexts), error handling, maps, testing.

Architecture:

microservices, event-driven design, data communication.

Cloud:

AWS (Lambdas, serverless), infra basics.

Messaging:

Kafka,

SQS/SNS

.

Data:

DynamoDB / NoSQL

(also Cassandra basics),

Postgres

(ALTER/indexing/replication).

Interfaces:

gRPC

.

Security:

OAuth 2.0, JWT

.

Code quality:

"

vibe coding

" = idiomatic, readable, maintainable Go.
Note: We require understanding of concepts, not just recitation.5) Expected Interview Coverage (so agencies can pre-screen)

Project deep-dive:

Overview &

architecture

of current/last project;

team structure

; candidate's role/impact.

Concurrency mini-task:

Small code discussion or snippet (worker pool / fan-out-fan-in) +

channel usage

.

AWS Lambdas:

Where they used Lambdas, patterns for retries/backoff;

how they solved issues

.

Event-driven system:

Design choices (topic/queue, ordering, idempotency, DLQ).

Data:

DynamoDB:

partition/GSI design, pagination, hot partition avoidance.

Postgres:

an

ALTER

example;

indexing

strategy;

replication

basics.

Event-driven in Postgres

(e.g., outbox, NOTIFY/LISTEN, CDC--at a high level).

Performance & reliability:

Troubleshoot

API slowness

(profiling, N+1, caching, indexes, timeouts);

query slowdown

approach.

Quick reasoning checks:

e.g.,

GST 28% on 100

; mapping a business rule to code/data model.
6) Disqualifiers (Immediate "No")

Only academic/POC experience;

no production deployments

. Cannot explain

own work

or

architecture

coherently. Weak

DynamoDB

fundamentals (poor modeling; unaware of GSIs/partitions). Cannot write or reason about basic

Go concurrency

/

channels

. No experience with

event-driven

patterns or

gRPC

in practice
Job Types: Full-time, Permanent

Pay: ₹3,000,000.00 - ₹3,500,000.00 per year

Application Question(s):

Have you built, deployed, and supported live systems? Do you have experience in Event-driven architecture:Kafka/SQS/SNS, idempotency, retries, dead-lettering.? Have you worked with AWS withLambdas& serverless patterns.?
Experience:

Golang: 5 years (Required) React Js: 1 year (Required)
Work Location: Remote