Sakthivel Periyasamy
Software Developer
4+ years exp
Python
Node JS
JavaScript
Bash
Go
API Design: 5/10
Data Layer & Database: 5/10
System Architecture: 5/10
Active 14 days ago
+93 (61) 579637 Invite to interview
Message
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.
Technical skills
Python
Node JS
JavaScript
Bash• Senior
Go• Senior • 4y+
Node JS
Electron• 4y+
Go
Gin
GolangCI-Lint
Testify
Databases
SQLite
PostgreSQL• 4y+
ElasticSearch
Pinecone
Redis
AI/ML
AI Agents
LangGraph
RAG
LangChain
DevOps
Amazon EC2
AWS Lambda
Docker
GitHub Actions
gRPC
Platform Engineering
Vector
minikube
Docker Compose
Containers
Alpine Linux
GitOps
AWS• 4y+
CI/CD• 4y+
Jenkins• 4y+
ArgoCD
Grafana
Helm
Kubernetes
Prometheus
Rest API
Cybersecurity
Trivy
gosec
Gitleaks
AppSec
Threat Modeling• 4y+
IoT
MQTT• 4y+
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.
Gosince 2022
AWSsince 2022
MQTTsince 2022
Jenkinssince 2022
CI/CDsince 2022
PostgreSQLsince 2022
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• Senior • 4y+
Node JS
Electron• 4y+
Prometheus
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• 4y+
GitOps
ArgoCD
Kubernetes
Grafana
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• 4y+
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: