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

Job Mode:

Notice Period: Immediate to 30 Days Max

Role: Golang Backend Engineer (with React exposure)

Experience:

Salary Range :

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:

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