Golang(80%)+React(20%) Developer for one the growing Digital Transformation company

Job Mode : Permanent Remote

Notice Period : Immediate to 30 Days Max

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

Salary Range : Upto 25 LPA.

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

Experience : 5–8 years |

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 with

Messaging : Kafka,

SQS / SNS .

Data : Strong

(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 :

how they solved issues .

Event-driven system :

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

Data : Strong

partition / GSI design, pagination, hot partition avoidance.

Postgres : an

ALTER

indexing

replication

basics.

Event-driven in Postgres

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

Performance & reliability :

Troubleshoot

API slowness

query slowdown

approach.

Quick reasoning checks :

e.g.,

GST 28% on 100 ; mapping a business rule to code / data model.

6) Disqualifiers (Immediate “No”)

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