Gurveer Singh

Backend • Senior • New Delhi, India • UTC+05:30 • Relocation • Work permits: India • Citizenship: India • English: B2 • Can start now • from $10k per year

Software Developer

Node JS

JavaScript

Python

SQL

Java

C++

Scalability & Performance: 5/10

System Architecture: 5/10

Reliability & Observability: 5/10

Active 1 day ago

Invite to interview

Download CVCV

Overview

Technical skills

Projects

Timeline

Roles

Overview

Backend Go engineer (Senior) focused on building resilient background processing and real-time systems. The strongest proven skill is designing Redis-backed background queues with retries, dead-lettering and graceful shutdown as implemented in goqueue/internal/server/processor.go and goqueue/internal/broker/redis.go. Public code lacks automated tests, formal API versioning, and production-grade secrets or auth handling.

Phone

Technical skills

Languages

Node JS

JavaScript

Python

SQL

Java

C++

DevOps

AWS

Git

Docker

Linux

Rest API

Other

React.js

PostgreSQL

Go-redis

Redis

Firebase

Gorilla

GORM

gRPC

Selenium

Appium

TestNG

GitHub

GitHub Actions

WebSockets

Observability

Ollama

Windows

Projects

NetWatch

Built an authenticated Go monitoring service that ingests Linux, Windows, and simulated device telemetry into Redis Streams. Implemented consumer-group processing with recovery for abandoned messages, dead-letter routing, and idempotent PostgreSQL writes for telemetry and incidents. Added Ollama-based incident analysis using durable PostgreSQL jobs and tested stream deduplication and recovery.

GoQueue

Developed a reusable Redis-backed job queue in Go with separate producer and worker components. Implemented immediate, delayed, and scheduled task execution using Redis lists and sorted sets, plus configurable worker pools. Validated the queue performance with a local load test covering high task throughput and low enqueue-to-ack latency.

Timeline

Associate Software Developer • Middle

Pantelwar • Full-Time

Apr 2025 to Oct 2026 1 Year 6 Months Noida In office

Built multiple REST APIs in Go for payment, user, and adviser services supporting fintech investment workflows. Implemented asynchronous payment webhook handlers with signature verification, idempotency checks, and retry/error handling for duplicate or failed callbacks. Developed PostgreSQL-backed bonus and demerger workflows and integrated AWS SES/SNS plus Firebase Cloud Messaging for notifications. Added Go unit tests and debugged production issues using Docker/Linux tooling and service logs.

PostgreSQL

Redis

gRPC

AWS

Firebase

Docker

Linux

Software Engineer Intern • Junior

BlueStock.in • Internship

Oct 2024 to Nov 2024 1 Month Pune In office

Contributed to development work during the internship using React for the UI and Node.js/Express for backend services. Used MongoDB for data storage and Git for source control management.

React.js

Node JS

Git

Senior Backend Developer Confidence: High Distributed Systems

API Design

4/10

How well APIs are designed

API surface is pragmatic and consistent (client/server, stats, health, idempotency hooks) but lacks explicit versioning, a formal error contract, and documented idempotency semantics for callers.

Evidence

goqueue/goqueue.go: public NewClient/NewServer, IdempotencyKey and Enqueue APIs

goqueue/internal/client/client.go: input validation and Enqueue/EnqueueAt signatures with clear error returns

log-aggregator/cmd/server/httpserver/main.go: /log and /ws endpoints and JSON response handling

Data Layer & Database

4/10

Working with databases

Data layer shows deliberate Redis patterns (pipelines, sorted sets, task metadata) and idempotency handling but there is no SQL migration history, tuning notes, or explicit transaction/isolation considerations beyond Redis pipelining.

Evidence

goqueue/internal/broker/redis.go: Enqueue/Dequeue/Ack/Nack/DeadLetter implemented with Redis HSET/LPUSH/ZADD and pipelines

goqueue/internal/server/recoverer.go: reads task payloads, handles missing payloads and re-queues with updated retry state

Scalability & Performance

5/10

Handling load and speed

Scalability and performance are considered: bounded worker concurrency, retry/backoff, batch-based forwarder/recoverer and use of Redis pipelines; missing are documented load testing, cache invalidation strategies, or global coordination for multi-node deployments.

Evidence

goqueue/internal/server/processor.go: semaphore-based worker pool, graceful drain and work timeout handling

goqueue/internal/server/recoverer.go: batch recovery and re-queue with backoff

log-aggregator/internal/buffer/ring-buffer.go: in-memory ring buffer for recent logs

System Architecture

5/10

Overall system structure

Code shows intentional module boundaries (broker, client, server, forwarder, recoverer, mux, hub) and clear separation of concerns; cross-service contracts and multi-node coordination are not demonstrated.

Evidence

goqueue/goqueue.go: wires broker, mux, processor, forwarder and recoverer to form the server

goqueue/internal/mux/mux.go: serve mux abstraction for task handlers

log-aggregator/internal/hub/hub.go: pub-sub hub for broadcasting log entries

Security & Auth

2/10

Protecting data and access

Only minimal security hygiene is evident: basic input validation and idempotency checks; there is little to no evidence of authentication/authorization, secret management, dependency auditing, or hardened input validation in backend components.

Evidence

work-lookup/content.js: WORD_RE enforces single-word selection before lookup

goqueue/internal/broker/redis.go: idempotency Exists check before enqueue

Reliability & Observability

5/10

Stability and monitoring

Reliability is well addressed for a developer library: retry/backoff, dead-lettering, recoverer to find stale work, graceful shutdown/drain, and timeouts in client code; observability is basic (logs and a Stats method) but lacks structured metrics/alerting.

Evidence

goqueue/internal/server/processor.go: panic handling, retries, DeadLetter/Nack/Ack and graceful drain logic

goqueue/internal/server/recoverer.go: scheduled recovery of stale active tasks and controlled re-queueing

work-lookup/background.js: AbortController with timeout for external provider calls

Expertise

Go Development• Senior

Messaging & Real-time• Senior

Industries

Financial Services• Middle

Technologies

Node JS• since 2024

Rest API

gRPC• since 2025

Gorilla

Go-redis

Recommendations

Develop resilient background job systems and queue orchestration (delayed work, retries, dead-letter handling) using the existing goqueue components.
Build realtime logging/observability services (TCP intake, WebSocket broadcast, metrics) leveraging the log-aggregator hub and ring buffer patterns.
Create developer-facing SDKs or integration libraries for services that need reliable task enqueueing and idempotency guarantees.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

work-lookup log-aggregator goqueue

Senior DevOps Engineer Confidence: High Generalist

Senior Go backend generalist specializing in building concurrent background job systems and lightweight observability tooling. The strongest proven skill is reliable background processing and recovery, exemplified by the goqueue components (processor.go, recoverer.go, broker/redis.go) implementing concurrency control, drain/shutdown, dead-lettering and retry/backoff. There is little to no public evidence of CI/CD, infrastructure-as-code, container orchestration, formal SLOs or automated infra testing in the analyzed human-authored artifacts.

CI/CD Pipelines

Automated build and deploy

Not evidenced in public code

Infrastructure as Code

Managing servers with code

Not evidenced in public code

Containerization & Orchestration

Working with containers

Not evidenced in public code

Observability & Monitoring

4/10

Watching system health

Concrete observability work is present via a custom log-aggregator with TCP ingest, a websocket streaming endpoint, an in-memory ring buffer and subscriber hub; this is application-level observability plumbing but lacks advanced SLO/alert/burn-rate rules or dashboard-as-code.

Evidence

Gurveer1510/log-aggregator/pkg/client/client.go: TCP log client writing JSON lines to the collector Gurveer1510/log-aggregator/cmd/server/tcpserver/main.go: TCP ingest server that parses incoming JSON logs and broadcasts to hub Gurveer1510/log-aggregator/cmd/server/httpserver/main.go: WebSocket endpoint streaming log entries from hub to clients

Reliability & Incident Response

5/10

Keeping systems up

Strong reliability-focused patterns are implemented in the queue system: background forwarder/recoverer, dead-lettering, idempotency checks, exponential backoff and a processor with concurrency control and graceful drain on shutdown; this shows thoughtful operational design for job reliability but lacks infra-level DR rehearsal, chaos experiments, or documented runbooks.

Evidence

Gurveer1510/goqueue/internal/server/processor.go: concurrency semaphore, task processing, panic recovery and drain() for graceful shutdown Gurveer1510/goqueue/internal/broker/redis.go: dead-lettering, Nack/Ack, idempotency key checks and backoff() implementation Gurveer1510/goqueue/internal/server/recoverer.go: background recoverer that finds stale active tasks and re-queues or dead-letters them

Cloud & Cost Optimization

Smart use of the cloud

Not evidenced in public code

Expertise

Observability & Monitoring• Middle

Site Reliability Engineering• Middle

Industries

Software• Middle

Technologies

Observability

Go• since 2025 • Senior

WebSockets

Recommendations

Lead development of Go-based background processing systems, worker pools and queue integrations (Redis-backed) including production hardening and runbooks.
Build lightweight observability endpoints and ingestion pipelines (TCP/WS ingest, buffering, subscriber hubs) and extend them with metrics, dashboards and alerting as code.
Implement CI/CD and IaC for these services (pipeline templates, container builds, Kubernetes manifests or simple autoscaling docs) to make deployments reproducible and safer.
Harden operational hygiene: add structured SLOs/alerts, incident runbooks, and automated integration tests (integration or terratest-style) for queue and recovery behaviors.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

log-aggregator goqueue url_shortner_2

Senior Blockchain Developer Confidence: High Infrastructure Engineer

Infrastructure-focused Go engineer (senior-level) specializing in backend tooling such as background job queues and log aggregation. The strongest proven skill is designing concurrent, Redis-backed background job systems with recovery and dead-letter handling, evidenced by goqueue/internal/server/processor.go, goqueue/internal/server/recoverer.go and goqueue/internal/broker/redis.go. There is no public evidence of smart contract, blockchain protocol, formal security audits, or comprehensive automated tests and CI for these projects.

Smart Contract Development

Writing smart contracts

Not evidenced in public code

Security & Audit

2/10

Checking contracts for flaws

Basic operational security and robustness patterns exist (idempotency checks, panic recovery, retry and dead-letter handling) but there is limited formal security/audit work, testing, or hardening; a few permissive defaults increase risk.

Evidence

goqueue/internal/broker/redis.go: Enqueue checks idempotency key using keyIdempotency before pushing task

goqueue/internal/server/processor.go: panic recovery with Nack and dead-letter logic and explicit retry counting

log-aggregator/cmd/server/httpserver/main.go: websocket Upgrader has CheckOrigin returning true (permissive origin policy)

Blockchain Protocol Understanding

Knowing how blockchains work

Not evidenced in public code

DApp & Web3 Integration

Connecting apps to blockchain

Not evidenced in public code

Tokenomics & DeFi Logic

Token and finance logic

Not evidenced in public code

Decentralization & Trust Model

Designing trust without middlemen

Not evidenced in public code

Industries

Software• Middle

Recommendations

Use to build and harden backend infra services in Go - background job processors, delivery guarantees, and logging pipelines.
Work on production hardening of queue systems: add metrics, structured logging, TLS/auth, integration tests and CI, and stricter websocket origin handling.
Develop browser extension UX and small JS tooling where light, secure client-side code is needed (the word lookup extension is a good fit).

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

work-lookup log-aggregator goqueue