Sakthivel Periyasamy
Software Developer
4+ years exp
Go
Bash
Python
JavaScript
Node JS
API Design: 5/10
Data Layer & Database: 5/10
System Architecture: 5/10
Invite to interview
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
A pragmatic senior-level engineer focused on building and securing developer tooling and local platform automation with solid hands-on Go back-end work and CI/CD orchestration. The strongest proven skill is designing and hardening a local DevOps/DevSecOps learning platform - evidenced by the Jenkins bootstrap scripts, Makefile security targets, and Dockerfile runtime hardening. There is limited public evidence of formal vulnerability research, protocol/crypto design, or detection-rule engineering in human-authored code.
Phone
Technical skills
Languages
5
Go
Bash
Python
JavaScript
Node JS
Go
3
Gin
Testify
GolangCI-Lint
DevOps
9
AWS
CI/CD
Kubernetes
Grafana
Jenkins
Prometheus
ArgoCD
Rest API
Helm
Databases
5
PostgreSQL
ElasticSearch
Redis
Pinecone
SQLite
Other
23
Electron
MQTT
LangGraph
Threat Modeling
RAG
Docker Compose
LangChain
Trivy
gosec
Amazon EC2
AWS Lambda
GitOps
GitHub Actions
minikube
Containers
Alpine Linux
Gitleaks
AppSec
Docker
gRPC
AI Agents
Platform Engineering
Vector
Timeline
Software Developer (Backend & AI Platform)
•
Middle
Rently Software Development Pvt Ltd
•
Full-Time
Designed and built an agent-driven lifecycle system using LangGraph to automate end-to-end software development activities from requirements to deployment. Implemented an AI production support agent using RAG with Pinecone and Elasticsearch plus MCP integrations for incident analysis and root-cause workflows. Built event-driven microservices in Go on AWS (Kinesis/SQS) to process millions of events with high delivery reliability. Led CI/CD for Kubernetes using Jenkins, Helm, and ArgoCD, and improved observability and API performance using Prometheus/Grafana, CloudWatch, PostgreSQL optimization, and Redis caching.
Go
LangGraph
RAG
Pinecone
ElasticSearch
AWS
Kubernetes
Jenkins
Helm
ArgoCD
CI/CD
Prometheus
Grafana
PostgreSQL
Redis
Rest API
MQTT
Associate Software Developer (Backend)
•
Middle
Rently Software Development Pvt Ltd
•
Full-Time
Developed fault-tolerant backend processing using retry strategies with DLQs, exponential backoff, and idempotent consumer patterns. Built AWS-based serverless ingestion pipelines using SQS and Go, improving throughput and reducing infrastructure load and costs. Optimized high-concurrency Go services and strengthened reliability with unit testing and expanded automated test coverage. Also worked on secure IoT workflows, including MQTT protocol optimization and a secure boot/key-management framework using AWS S3 plus a cross-platform Electron+Go desktop tool for firmware flashing.
Go
AWS
MQTT
Jenkins
CI/CD
PostgreSQL
Electron
Threat Modeling
Bannari Amman Institute of Technology
Bachelor's Degree •
Electrical and Electronics Engineering
Senior Backend Developer
Confidence: High API Engineer
A backend Go engineer with strong practical skills in service design and deterministic testing at a Senior level. The most proven strength is concurrent and deterministic time/test infrastructure - visible in the fake clock implementation and extensive clock tests (clock/clock/fake.go and clock/clock/fake_test.go). There is limited public evidence of large-scale distributed system design, cloud infra/ops, or advanced auth/token lifecycle management.
API Design
5/10
How well APIs are designed
Consistent error envelope and JSON helpers with clear handler patterns and route registrations, but no visible versioning/idempotency strategy beyond conventional REST patterns.
Evidence
backend/internal/httpx/errors.go
backend/internal/httpx/json.go
backend/internal/download/routes.go
Data Layer & Database
5/10
Working with databases
Hand-written SQL repository code with seeding, upsert, and tests; migration and DB-open helpers exist, showing care for schema and evolution, but no complex sharding/partitioning or explicit transaction isolation tuning.
Evidence
backend/internal/settingsapi/repository.go
backend/internal/dbx/dbx.go
backend/internal/download/repository.go
Scalability & Performance
4/10
Handling load and speed
Thoughtful rate-limiting and scheduler use (cron), plus aggregator prioritization; some scalability patterns exist but no advanced caching/partitioning or measured performance artifacts.
Evidence
backend/internal/providers/ratelimiter.go
backend/internal/providers/aggregator_test.go
backend/internal/scheduler/service.go
System Architecture
5/10
Overall system structure
Clear package decomposition (providers, download, folder, settingsapi, scheduler, switcher) and dependency injection style constructors; sound boundaries for a single-service architecture but not a multi-service distributed design.
Evidence
backend/internal/scheduler/service.go
backend/internal/switcher/service.go
backend/internal/settingsapi/repository.go
Security & Auth
4/10
Protecting data and access
Reasonable surface-level security hygiene - secrets are not echoed, exec uses argv arrays to avoid shell interpolation, and APIs avoid returning raw API keys; no advanced auth/token lifecycle or dependency-audit artifacts are present.
Evidence
backend/internal/settingsapi/repository.go
backend/internal/switcher/service.go
backend/internal/httpx/errors.go
Reliability & Observability
5/10
Stability and monitoring
Good reliability practices - deterministic fake clock for testing concurrency, cron engine lifecycle handling, mutex-protected state and structured logging; retries/backoff patterns exist in network utilities but full circuit-breaker/observability stacks are limited to local logging/Prometheus hooks in other modules.
Evidence
clock/clock/fake.go
backend/internal/scheduler/service.go
backend/internal/logging/logging.go
Expertise
Go Development• Senior
Microservices & API Architecture• Middle
Technologies
Go• since 2022 • Senior
Node JS
Electron• since 2022
Prometheus• since 2025
Gin
SQLite
Testify
Recommendations
- Develop system-level backend services or local system integrations (e.g., desktop tooling, OS integrations) that require careful external command handling and file-system safety.
- Implement resilient cron-driven workflows and background jobs where deterministic testing and scheduler lifecycle control are important.
- Build well-tested core libraries (timing, rate-limiters, circuit breakers) and backend APIs that require thorough unit and integration tests.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior DevOps Engineer
Confidence: Medium CI/CD Engineer
A pragmatic CI/CD-focused engineer at a senior entry level who builds and automates local GitOps/CI sandboxes and well-tested Go services. The strongest proven skill is platform orchestration and CI automation, evidenced by the bootstrap scripts and Jenkins init.groovy seeding in local-cicd-platform/scripts/install-jenkins.sh and the overall bootstrap orchestration in local-cicd-platform/scripts/bootstrap.sh. There is limited public evidence of production-grade IaC modules with remote state, progressive delivery (canary/blue-green) automation, or SLO-driven alerting and incident runbooks.
CI/CD Pipelines
5/10
Automated build and deploy
Concrete CI/CD automation and platform orchestration (Jenkins seeding, credential management and bootstrap orchestration) but missing advanced pipeline engineering patterns like reusable workflows, artifact signing or deploy gates.
Evidence
local-cicd-platform/Makefile: bootstrap, setup and orchestration targets for the local platform
local-cicd-platform/scripts/install-jenkins.sh: init.groovy.d scripts that seed jobs, manage credentials and configure SCMTrigger
local-cicd-platform/infrastructure/jenkins/Dockerfile: custom Jenkins image that installs scanning and linting tools
Infrastructure as Code
3/10
Managing servers with code
Pragmatic scripted infrastructure and Helm-based installs for a local learning sandbox, but no versioned IaC modules, remote state, or state-migration evidence.
Evidence
local-cicd-platform/scripts/bootstrap.sh: orchestrates Minikube, Harbor, ArgoCD and monitoring installation
local-cicd-platform/scripts/install-monitoring.sh: Helm upgrade/install of kube-prometheus-stack with tuned values for Minikube
Containerization & Orchestration
5/10
Working with containers
Good containerization hygiene and Kubernetes usage for a local platform - multi-stage Go build, non-root runtime user, healthcheck and Helm-based installs - but lacks advanced pod-level resilience primitives in the shown files.
Evidence
go-api/Dockerfile: multi-stage build, non-root user creation, static-linked binary and HEALTHCHECK
local-cicd-platform/scripts/install-monitoring.sh: Helm settings and resource tuning for kube-prometheus-stack
local-cicd-platform/Makefile: port-forward targets and dev/stage/prod namespace orchestration
Observability & Monitoring
4/10
Watching system health
Observability is present via Prometheus/Grafana installs and metrics endpoint exposure; however there is no evidence of SLO-based alerting, burn-rate rules or advanced alert routing in the public scripts.
Evidence
local-cicd-platform/scripts/install-monitoring.sh: installs kube-prometheus-stack with Grafana sidecar for dashboards
go-api/Dockerfile: container HEALTHCHECK declared
Reliability & Incident Response
4/10
Keeping systems up
Application-level reliability practices are evident (cron-driven scheduler with safe start/stop, mutexing, and many unit tests); there is little public material about progressive delivery or documented incident DR rehearsals.
Evidence
backend/internal/scheduler/service.go: cron engine orchestration, ApplySchedule, safe stop/start and RunAutoDownloadCycle
backend/internal/switcher/service.go: explicit error handling and clear install/configure/enable flows
Cloud & Cost Optimization
3/10
Smart use of the cloud
Some cost/resource-minded choices for a local dev/minikube environment (small resource requests for monitoring, ephemeral storage), but no evidence of autoscaling strategy, rightsizing analysis or cloud cost engineering.
Evidence
local-cicd-platform/scripts/install-monitoring.sh: tuned resource requests/limits for Grafana and Prometheus to fit Minikube
local-cicd-platform/scripts/bootstrap.sh: starts Minikube with an insecure registry and creates dev/stage/prod namespaces
Expertise
Platform Engineering & IDP• Senior
Observability & Monitoring• Middle
Technologies
Containers
Bash• Senior
Docker Compose
CI/CD• since 2022
GitOps
ArgoCD• since 2025
Kubernetes• since 2025
Grafana• since 2025
GolangCI-Lint
minikube
Alpine Linux
Recommendations
- Lead development of declarative, versioned IaC modules (Terraform/CloudFormation/CDKTF) with remote state and locking to replace ad-hoc bootstrap scripts.
- Add progressive delivery and deploy gates (canary or blue-green) into the CI pipelines and document rollback criteria and automated rollback steps.
- Implement SLI/SLO-driven alerting and burn-rate rules in Prometheus + Alertmanager and add alert routing/inhibition to reduce noise.
- Harden secrets and credentials by adopting workload identity (or sealed secrets/Vault) and remove plaintext default passwords from scripts and templates.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Senior Security Engineer
Confidence: High Cloud Security Engineer
A pragmatic senior-level engineer focused on building and securing developer tooling and local platform automation with solid hands-on Go back-end work and CI/CD orchestration. The strongest proven skill is designing and hardening a local DevOps/DevSecOps learning platform - evidenced by the Jenkins bootstrap scripts, Makefile security targets, and Dockerfile runtime hardening. There is limited public evidence of formal vulnerability research, protocol/crypto design, or detection-rule engineering in human-authored code.
Vulnerability Analysis
2/10
Finding security weaknesses
Lightweight vulnerability-analysis posture: the workspace integrates static and supply-chain scanners and CI checks, but there is no evidence of root-cause vulnerability writeups, reproducible PoCs, or exploitability analysis in human-authored code.
Evidence
go-api/Makefile: security target runs gosec, govulncheck, gitleaks, trivy
local-cicd-platform/Makefile: security target delegates to go-api security target
local-cicd-platform/infrastructure/jenkins/Dockerfile: installs gosec, trivy, gitleaks and govulncheck tools
Cryptography & Secure Protocols
2/10
Using encryption correctly
Minimal cryptography/protocol work - scripts and infra handle SSH keys and ephemeral secrets, but there are no protocol designs or crypto primitives implemented; some risky defaults (e.g. SSH strict host key checking disabled) are present.
Evidence
local-cicd-platform/scripts/install-jenkins.sh: generates JENKINS_ADMIN_PASSWORD with openssl rand and injects SSH private key into Groovy credential script
local-cicd-platform/scripts/install-tools.sh: fetches Trivy and other tooling (shows awareness of supply-chain/security tooling)
Offensive Security / Pentesting
1/10
Testing by attacking
No offensive-security research or scoped pentest artifacts; only defensive/off-the-shelf scanners are integrated.
Evidence
local-cicd-platform/scripts/install-tools.sh: installs offensive/scan tooling like trivy and gosec (tooling presence only)
local-cicd-platform/infrastructure/jenkins/Dockerfile: installs gitleaks (scanner), not a PoC or exploit
Defensive Hardening
5/10
Making systems harder to break
Strong evidence of defensive hardening and platform hygiene - non-root runtime containers, healthchecks, CI security checks, credential provisioning automation, and cautious Helm/Kubernetes install flags - showing practical secure-by-default choices for a learning/local platform.
Evidence
go-api/Dockerfile: creates non-root appuser, sets healthcheck and drops root
local-cicd-platform/scripts/install-jenkins.sh: idempotent credential provisioning and careful handling of SSH key/robot credential insertion into Jenkins (replaceCredentials pattern)
local-cicd-platform/scripts/install-monitoring.sh: Helm install with admission webhooks disabled and conservative resource settings for a local cluster
Detection & Incident Response
2/10
Spotting and handling attacks
Basic observability and monitoring infrastructure is assembled (Prometheus/Grafana) but there are no detection rules, alerts, ATT&CK mappings, or curated FP/FN analysis present in human-authored artifacts.
Evidence
local-cicd-platform/scripts/install-monitoring.sh: bootstraps kube-prometheus-stack and writes Grafana/Prometheus access info
local-cicd-platform/Makefile: targets for logs-dev/logs-stage/logs-prod and port-forward helpers
Compliance & Threat Modeling
2/10
Planning against threats
Some operational security and process-level controls are present (credential rotation, least-privilege runtime user, SBOM tooling), but there is no formal threat model, STRIDE/attack-tree, or compliance artifacts.
Evidence
local-cicd-platform/scripts/install-jenkins.sh: explicit credential replacement logic to avoid stale credentials
go-api/Dockerfile: uses non-root user and documents healthcheck and minimal runtime surface
Expertise
DevSecOps & Cloud Security• Senior
Industries
Software• Middle
Technologies
AppSec
JavaScript
Trivy
Gitleaks
Threat Modeling• since 2022
gosec
Recommendations
- Lead development of CI/CD pipelines and DevSecOps automation (Jenkins/Helm/Minikube/Harbor) and integrate security scanners into PR pipelines with gating and SBOM generation.
- Harden containerized Go services for production (supply-chain scanning, runtime least-privilege, secure image build pipelines and automated vulnerability patching).
- Build secure platform onboarding flows and credential rotation automation (improve secret handling, avoid disabling SSH host checks, integrate HashiCorp Vault for secrets).
- Own monitoring + detection work by instrumenting Prometheus metrics with alerts and translating operational signals into simple detection/playbooks.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: