Golang Engineer

Anblicks Inc.; Dallas, Northern (TX, KY); Hybrid; USD 120,000 - 160,000; Full time

Job summary

Anblicks Inc. seeks a Go-focused software engineer to design and build integration services and APIs. You’ll implement event-driven flows with SQS, SNS, and Lambda, containerize services, and deploy to EKS/Kubernetes, owning Helm charts and rollout strategies.

You’ll model data access on RDS, enforce observability with structured logging and tracing, and drive versioned contracts. The role includes CI/CD, testing, and mentoring mid-level developers in cloud-native practices.

Qualifications

• 3+ years writing production Go; strong grasp of goroutines, channels, context propagation, error handling, and interface-driven design.
• Experience with Go web/API frameworks and gRPC or REST service development.
• Comfortable profiling and tuning Go services (memory, concurrency, latency).
• Working command of enterprise integration patterns and their real trade-offs.
• Strong understanding of canonical data models for integration and mapping.
• Hands-on with EKS and Kubernetes deployments and troubleshooting.

Responsibilities

• Design and build integration services and APIs in Go.
• Build event-driven flows using SQS, SNS, and Lambda with ordering and deduplication.
• Containerize services and deploy to EKS/Kubernetes with Helm charts.
• Model and optimize data access against RDS and migrations.
• Document API and event schemas and drive versioning discipline.
• Establish observability: structured logging, metrics, tracing, alerting on SLAs.
• Contribute to CI/CD, testing (unit/contract/integration), and non-functional validation.
• Mentor mid-level developers and communicate design risks to Tech Lead.

Skills

Go production

Goroutines

REST/gRPC

API frameworks

Profiling Go

Enterprise patterns

Canonical data models

iPaaS platforms

Clean architecture

EKS/Kubernetes

Docker

SQS/SNS/Lambda

RDS tuning

IAM/VPC/Secrets

Tools

Go web/API frameworks

gRPC/REST

Kubernetes tooling

Job description

• Design and build integration services and APIs in Go, applying appropriate integration and design patterns (message routing, transformation, idempotency, retry/backoff, circuit breaker, saga/compensation, outbox).
• Build event-driven flows using SQS, SNS, and Lambda — including ordering, deduplication, dead-letter handling, and replay strategy.
• Containerize services and deploy to EKS/Kubernetes; own Helm charts, resource sizing, health/readiness probes, autoscaling, and rollout strategy.
• Model and optimize data access against RDS (schema design, indexing, connection pooling, transaction boundaries, migrations).
• Translate integration requirements into interface contracts and sequence flows; document API and event schemas and drive versioning discipline.
• Build in observability from day one — structured logging, metrics, distributed tracing, alerting on integration SLAs.
• Use AI-assisted development tooling (e.g., Claude Code, GitHub Copilot, Cursor) to accelerate delivery, and enforce review discipline so AI-generated code meets the same quality and security bar.
• Contribute to CI/CD pipelines, automated testing (unit, contract, integration), and non-functional validation (load, failover, resiliency).
• Provide code review, mentoring, and technical guidance to mid-level developers; raise design risks early to the Tech Lead.

Must-Have Qualifications

• 3+ years writing production Go; strong grasp of goroutines, channels, context propagation, error handling, and interface-driven design.
• Experience with Go web/API frameworks and gRPC or REST service development.
• Comfortable profiling and tuning Go services (memory, concurrency, latency).
• Working command of enterprise integration patterns (Hohpe/Woolf) and their real trade-offs: sync vs. async, orchestration vs. choreography, guaranteed delivery, exactly‑once vs. at‑least‑once, idempotent consumers.
• Strong understanding of canonical data models for integration — designing a canonical/common schema layer, mapping source and target payloads to and from it, and knowing when a canonical model is the right call versus point‑to‑point or a per‑domain contract.
• Basic knowladge of one or more iPaaS platforms — MuleSoft, Boomi, Workato, Azure Logic Apps, Informatica, TIBCO, webMethods, or similar — including connector development, mapping/transformation, and orchestration.
• Practical experience with design patterns (creational/structural/behavioral) and clean architecture, SOLID, and domain boundaries — able to justify choices, not just name them.
• Experience with API contracts, schema evolution, and backward compatibility.
• Hands‑on with EKS and Kubernetes — deployments, services, ingress, config/secrets, HPA, troubleshooting live workloads.
• Understanding of containerization skills (Docker: multi-stage builds, image hardening, small runtime images).
• Knowladge about SQS, SNS, and Lambda in event-driven architectures.
• Understanding of RDS (PostgreSQL or MySQL) including performance tuning.
• Knowladge about IAM, VPC/networking basics, Secrets Manager/Parameter Store, and CloudWatch.

AI in the Development Lifecycle

• Demonstrable experience using AI coding assistants in real delivery — able to describe what they accelerated, where the tooling failed, and how they validated output.
• Understanding of prompt/context practices for codebases, plus the guardrails: security review, licensing, and hallucination checks.
• Git-based workflow, trunk/branching discipline, CI/CD (GitHub Actions, GitLab CI, Jenkins, or similar).
• Test automation habit — unit, contract, and integration testing as part of definition of done.
• Clear written and verbal communication with distributed teams and client stakeholders.