Hire Freelance
Backend Golang Developers

Develops Go services for cloud-security workflows, including vulnerability analyzers spanning multiple operating systems and programming languages. Works with Kubernetes cluster monitoring, container troubleshooting, and policy evaluation for vulnerability management.

• Kafka asynchronous messaging
• IBM MQ integrations
• OpenShift deployment workflows
• Dynatrace service monitoring

Engineered Go and gRPC microservices with Kafka-backed distributed pipelines supporting live workloads of up to 100,000 concurrent users. Refactored C# monoliths into cloud-native services across AWS, GCP, and Azure, with emphasis on reliability and observability.

• RabbitMQ event processing
• Redis-backed high-frequency data flows
• Terraform Kubernetes infrastructure
• Datadog, Prometheus, Grafana, and Jaeger monitoring

Engineers resilience testing platforms across bare metal, OpenStack, Kubernetes, AWS, and serverless environments. Designs controlled failure experiments covering network impairment, node disruption, EC2 and availability-zone failures, Lambda timeouts, dependency failures, and downstream degradation.

• Linux tc/netem network injection
• AWS FIS EC2 termination scenarios
• DaemonSet-based node disruption
• Blast-radius and failure-parity automation

Architected a Golang LLM inference proxy with OpenAI- and Anthropic-compatible APIs, integrating Qdrant vector retrieval for retrieval-augmented generation. Designs high-throughput cloud platforms spanning event-driven services, large-scale data engineering, and distributed systems across AWS, Azure, and GCP.

• Automated refactoring, test generation, and code review with Claude Code
• Applied OpenSpec workflows for spec-driven development
• Built Parquet and PySpark data lake pipelines
• Implemented Kubernetes operators and GitOps deployment patterns

Operates fault-tolerant Go microservices on AWS and Kubernetes for a verification platform serving millions of merchants. Designed Kafka consumers with at-least-once semantics, deduplication, retries, dead-letter handling, and provider abstractions for KYC/KYB integrations.

• gRPC API design
• DynamoDB persistence
• Terraform infrastructure provisioning
• 75% authentication-cost reduction

Developed Go microservices for a high-traffic commerce platform, including a product data service sustaining 5,000 requests per second with peaks near 20,000. Built Pub/Sub ingestion and synchronization pipelines processing approximately 60 million records across Kubernetes workloads.

• GCP Kubernetes production operations
• Grafana k6 performance testing in CI/CD
• Concurrency-driven throughput optimization
• Legacy platform migration engineering

Built Go microservices for a distributed document platform serving approximately 110,000 daily users, using Google Cloud Tasks and Pub/Sub for asynchronous lifecycle workflows. Replaced synchronous REST flows with retry-safe event processing backed by PostgreSQL metadata, Firestore content, Redis caching, and RBAC authorization.

• Implemented idempotent failure recovery
• Deployed services across AWS and GCP
• Built Prometheus production metrics
• Developed REST and gRPC interfaces

Built high-reliability payment platforms and more than 200 microservice components using Go and Rust, alongside Web3 infrastructure, smart contracts, and cross-chain services. Maintains an open-source Go multi-agent workflow orchestrator and operates tier-one transaction-processing systems with failure-oriented deployment and observability models.

• Kubernetes platform engineering
• Prometheus and Grafana operational telemetry
• Docker-based deployment automation
• Cross-chain backend integration

Architected a distributed enterprise data-exchange platform serving more than 600 applications across seven countries and approximately 70,000 daily transfers. Operated multi-petabyte streaming infrastructure across four production regions on OpenStack and AWS, and built an LLM-driven workflow execution product.

• Designed hybrid-cloud data movement across regions
• Built distributed API monitoring capabilities
• Integrated natural-language flow creation and debugging
• Developed GenAI-driven live workflow modification

Modernized a Go ingress router handling peaks above 15,000 requests per second for web, mobile, and AI-streaming traffic. Earlier work includes payment-processing systems and infrastructure/database migration that reduced recurring costs by more than 90%; also contributed signal.NotifyContext to the Go standard library.

• PostgreSQL with pgvector
• OpenTelemetry instrumentation
• Pulumi infrastructure as code
• Prometheus service metrics

Modernized legacy advertising systems into Go microservices on AWS and Kubernetes while continuing to implement production code. Builds distributed data platforms using Rust, Go, PostgreSQL, event processing, and columnar formats, with recent integrations for LLM agents and local model serving.

• Apache Arrow Flight pipelines
• Parquet and S3 datasets
• NATS and RabbitMQ messaging
• Kinesis and Firehose ingestion

Designed Go microservices for a recommendation platform handling more than 200,000 requests per second and over 100 million monthly users. Built Kafka and Redis metric aggregation with Prometheus/Grafana monitoring, reducing mean time to recovery by 40% through systematic production diagnostics.

• API mocking and automation frameworks
• Cloud-native Docker delivery pipelines
• Python and Java service integrations
• Production incident post-mortem workflows

Designed and launched a public REST management API for a cloud database platform, including versioning, API-key and JWT authentication, rate limiting, OpenAPI documentation, Kubernetes deployment, and an autogenerated Go SDK. Built an open-source Terraform provider supporting autoscaling, private connections, autosuspend, scale factors, and cache configuration.

• C++ software for heart-surgery planning
• Customer-facing developer tooling
• AWS, Azure, and GCP operations
• Upgrade and maintenance automation

Built Go backend services benchmarked at 8,420 requests per second with 11.45 ms p95 latency and no observed errors, using PostgreSQL, Redis, Kubernetes, and k6 validation. Reduced cluster spend by 35% through custom HPA/KEDA autoscaling, Calico/WireGuard networking, gRPC services, and OpenTelemetry instrumentation.

• Multi-provider LLM routing gateway
• MCP servers and Claude development skills
• OAuth2/OIDC multi-tenant authorization
• PgBouncer connection-pool tuning