Keshav Rajput

Cybersecurity • Senior

6+ years exp

Cryptography & Secure Protocols: 5/10

Defensive Hardening: 5/10

Active 8 days ago

Invite to interview

Message

Download CVCV

Overview

Technical skills

Roles

Overview

Go backend engineer (Senior) focused on authenticated REST APIs and distributed node synchronization with a strong emphasis on application-level security and correctness. The strongest proven skill is application authentication and token/password handling as implemented in authservice/pkg/service/authenticatorImpl.go and enforced by middleware in authservice/pkg/endpoint/middleware.go. There is little or no public evidence of cloud/IaC hardening, formal threat modeling, detection engineering or published vulnerability research and PoCs.

Technical skills

Go• Senior • 6y+

Gorilla

Gin

DevOps

WebSockets

Rest API

GitHub Actions

Docker Compose

Containers

Kubernetes

CI/CD

Cryptography

Senior Security Engineer Confidence: Medium AppSec Engineer

Vulnerability Analysis

2/10

Finding security weaknesses

Limited evidence of systematic vulnerability analysis or exploitability research; there are useful input-validation and error-response tests but no CVE-style root-cause writeups, PoCs, or responsible-disclosure artifacts.

Evidence

overlap-avalara/internal/api/overlap_test.go: tests for malformed JSON, missing fields and invalid dates

overlap-avalara/pkg/response/error_test.go: tests for error mapping and special-case RequestInvalid handling

Cryptography & Secure Protocols

5/10

Using encryption correctly

Practical, correct use of standard crypto primitives and auth protocols at the application level (bcrypt for password hashing, JWT handling and token parsing, secure API key generation), but no protocol design analysis or advanced crypto work.

Evidence

authservice/pkg/service/authenticatorImpl.go: bcrypt password hashing and token generation flows

authservice/pkg/endpoint/middleware.go: JwtAuthMiddleware and ApiKeyAuthMiddleware with token validation and revocation checks

guardianlink/nodea/service/nodea.go and nodeb/service/nodeb.go: use of crypto/sha256 for random-hash generation

Offensive Security / Pentesting

Testing by attacking

Not evidenced in public code

Defensive Hardening

5/10

Making systems harder to break

Solid application-level defensive engineering: authentication/authorization middlewares, structured error mapping, transaction/compensation patterns, tests and logging; lacks cloud/IaC hardening, RBAC policy-as-code or automated security gating evidence.

Evidence

authservice/pkg/endpoint/middleware.go: ApiKeyAuthMiddleware and JwtAuthMiddleware enforcing authn/authz

authservice/pkg/endpoint/auth.go: input validation, structured error responses and use of RespondError/RespondSuccess

guardianlink/nodea/service/nodea.go: transactional DB usage with mutex locking and compensation/rollback logic

Detection & Incident Response

Spotting and handling attacks

Not evidenced in public code

Compliance & Threat Modeling

Planning against threats

Not evidenced in public code

Technologies

Cryptography

Go• Senior • 6y+

Gin

Recommendations

Develop production-grade authentication and authorization services (JWT lifecycle, API key management, token revocation, rotation) using files like authservice/pkg/service/authenticatorImpl.go and authservice/pkg/endpoint/middleware.go as the base.
Build distributed, transactional microservices with compensating transactions and robust testing; expand the node sync and compensation patterns found in guardianlink/nodea/service/nodea.go and guardianlink/nodeb/service/nodeb.go.
Add security-focused artifacts: threat models, abuse cases and scoped PoCs for identified risks, plus regression tests that validate fixes to prevent regressions.
Improve observability and detection by adding structured audit logging, SIEM/metrics integration and simple detection rules to validate authentication failures and anomalous patterns.

Repositories

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

overlap-avalara guardianlink authservice

Middle Backend Developer Confidence: Medium API Engineer

A backend API-focused engineer (mid-level) who builds small, concurrent Go services integrating realtime STT/TTS and LLM APIs. The strongest proven skill is designing and implementing a single-process streaming pipeline with graceful shutdown and transcript batching, demonstrated by main.go, stt_deepgram.go and conversation.go. There is little or no evidence of database design, schema migrations, distributed system design, production-grade observability, or API contract/versioning in public code.

API Design

4/10

How well APIs are designed

Integrations and client-side API work are solid (WebSocket STT, HTTP TTS, env-based auth), but there is no API versioning, idempotency, or documented error contract design for external integrations.

Evidence

voice-recording/stt_deepgram.go: websocket dial + Authorization header and streaming audio to Deepgram

voice-recording/tts_deepgram.go: HTTP client call to Deepgram TTS with status check and Accept header

voice-recording/main.go: orchestration of LLM/STT/TTS pipelines and channels

Data Layer & Database

1/10

Working with databases

No database layer, migrations, or transactional work; only local file writes for audio data.

Evidence

voice-recording/audio.go: writes mic_input.raw and PlayPCM16 I/O handling

voice-recording/tts_deepgram.go: writes tts_output.raw after TTS response

Scalability & Performance

4/10

Handling load and speed

Thoughtful use of buffered channels and goroutines and a timer-based batching approach for transcripts, but no queueing, caching strategy, or load-tested scaling artifacts.

Evidence

voice-recording/main.go: buffered channels (audioFrames, transcripts, userQueries, assistantReplies) and goroutine orchestration with WaitGroup

voice-recording/conversation.go: grace-period commit timer to batch final transcripts

System Architecture

4/10

Overall system structure

Clear single-process modular decomposition (audio, STT, conversation manager, LLM, TTS) with context-based shutdown and separation of responsibilities; not a distributed microservice architecture.

Evidence

voice-recording/main.go: separate goroutines for capture, STT, conversation manager, LLM, and TTS with context cancellation and wg.Wait

voice-recording/conversation.go: encapsulated ConversationManager type handling buffering and state transitions

Security & Auth

3/10

Protecting data and access

Basic secrets hygiene (env/.env usage) and use of Authorization headers, but no OAuth/token lifecycle, no input validation layer, and limited security hardening.

Evidence

voice-recording/main.go: loads DEEPGRAM_API_KEY and OPENAI_API_KEY from environment using godotenv

voice-recording/stt_deepgram.go: Authorization header usage for Deepgram websocket

Reliability & Observability

4/10

Stability and monitoring

Good runtime reliability patterns for a small app: context cancellation, WaitGroup, channel closing, timer stop semantics and defensive logging; lacking structured tracing/metrics and retry policies.

Evidence

voice-recording/main.go: context.WithCancel, signal handling, and wg.Wait for graceful shutdown

voice-recording/conversation.go: careful timer Stop logic and mutex-protected state

voice-recording/stt_deepgram.go: clean close on context cancellation and handling of websocket close messages

Expertise

Go Development• Middle

Messaging & Real-time• Middle

Industries

Artificial Intelligence• Middle

Technologies

Rest API

WebSockets

Recommendations

Develop small to medium backend services that integrate external streaming APIs (STT/TTS/LLM) and require robust context-based shutdown and in-process backpressure handling.
Implement and harden real-time features such as websocket-based ingestion, buffering, and batching logic for voice/Ux pipelines.
Build API client libraries with explicit error contracts, retries with backoff and idempotency handling for external services.
Add structured observability (metrics, traces, correlation ids) and automated tests (unit + integration) for the streaming components.

Repositories

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

Data_Structure maching-engine voice-recording

Middle DevOps Engineer Confidence: Medium CI/CD Engineer

Middle-level Go engineer focused on CI/CD and reliable small services with a strength in building well-tested Go services and simple deployment automation. The strongest proven skill is delivering tested Go server logic and lifecycle-aware initialization as shown by internal/api/overlap_test.go, server/initserver_test.go and pkg/response/error_test.go. There is little public evidence of cloud infra engineering at scale, Terraform or GitOps, SLO-driven monitoring, or automated production-grade observability.

CI/CD Pipelines

3/10

Automated build and deploy

Basic CI/CD with health checks and scripted rollback steps, but lacking advanced pipeline features like reusable workflows, cache keys, matrices, or artifact signing.

Evidence

cicd/.github/workflows/rollback-pipeline.yml: GitHub Actions workflow that builds, runs, checks health and calls rollback scripts

cicd/rollback-pipeline.yml: pipeline with shell-based deployment and health-check rollback logic

cicd/rollback.sh: simple rollback script that checks out previous commit and redeploys

Infrastructure as Code

2/10

Managing servers with code

Minimal Infrastructure as Code evidence: Dockerfile and docker-compose are present but there are no versioned modules, remote state, environment-separated Terraform, or state/locking practices.

Evidence

overlap-avalara/Dockerfile: multi-stage Go build and runtime image

overlap-avalara/docker-compose.yml: basic compose service using :latest image

overlap-avalara/Makefile: build/run/test targets for local CI

Containerization & Orchestration

3/10

Working with containers

Containerization and basic orchestration scripting exist (multi-stage Docker build, kubectl rollout/undo usage) but there is no tuned resource requests/limits, readiness/liveness probes, PDBs, anti-affinity or GitOps operator.

Evidence

overlap-avalara/Dockerfile: multi-stage build producing a scratch/alpine runtime image

cicd/script_name.sh: kubectl rollout undo usage for rollback

cicd/.github/workflows/rollback-pipeline.yml: pipeline invokes kubectl apply and rollback commands

Observability & Monitoring

2/10

Watching system health

Lightweight observability: health and version endpoints plus log assertions in tests, but no SLO/SLA, alert routing, burn-rate alerts, or dashboards-as-code.

Evidence

cicd/main.go: /health and /version handlers used by CI health checks

overlap-avalara/server/initserver_test.go: tests asserting startup/shutdown logs and lifecycle behavior

cicd/.github/workflows/rollback-pipeline.yml: uses simple curl health checks as the primary monitoring gate

Reliability & Incident Response

4/10

Keeping systems up

Reliability and incident handling are considered: graceful shutdown, fx lifecycle tests and scripted rollback/undo paths are present, but incident automation and structured runbooks are absent.

Evidence

voice-recording/main.go: context cancellation, waitgroup coordination and deferred ShutdownAudio for graceful shutdown

overlap-avalara/server/initserver_test.go: fx lifecycle tests and startup/shutdown verification

cicd/rollback-pipeline.yml: automated rollback logic triggered by simple health checks

Cloud & Cost Optimization

1/10

Smart use of the cloud

Almost no cloud cost or autoscaling work is evidenced; no HPA/KEDA, spot/eviction handling, rightsizing, or IAM/workload identity practices found.

Evidence

overlap-avalara/Dockerfile: container build for runtime with no autoscaling hints

overlap-avalara/docker-compose.yml: local compose usage without cloud or cost controls

Expertise

Platform Engineering & IDP• Middle

Technologies

Containers

Docker Compose

GitHub Actions

Gorilla

CI/CD

Kubernetes

Recommendations

Lead development of small to medium Go microservices with unit and integration tests and clear lifecycle hooks.
Design and harden CI pipelines that include artifact versioning, caching, retry/backoff, and automated rollback gates.
Migrate container deployments to declarative k8s manifests with readiness/liveness probes, resource requests/limits and basic GitOps flow.
Expand observability by adding SLOs, Prometheus metrics and structured alerts to replace ad-hoc curl health checks.

Repositories

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

voice-recording overlap-avalara cicd