QA & Backend Engineer: JS, Go/Golang & Microservices

Stack

Go, JavaScript, React.js, Postgres, Kafka, NATS, Redis, Kubernetes, Docker, gRPC, HTTP

Read before applying

Strong Golang skills are mandatory.

This is not a manual QA role. You will write production-grade Go code.

Frontend work is also engineering + automation, not manual UI testing.

What we’re building

We’re building infrastructure that takes AI systems from dev → staging → production:

reliable deployments, service orchestration, observability, secure multi-tenant APIs,

and scalable messaging/data pipelines.

This is real production infrastructure, not demo systems.

Role focus

• ~60% QA / SDET ownership — correctness, resilience, and production readiness
• ~40% Backend Go engineering — building and evolving core services
• Frontend quality and engineering for React-based applications and widgets

What we need from you

We’re looking for engineers who think like quality-first system builders

Take a goal → design testable systems → ship → validate → iterate.

You communicate clearly async, proactively improve reliability, correctness,

performance, and reduce production risk.

Responsibilities

Backend QA / SDET (Primary – ~60%)

Own quality strategy for Go microservices and platform components.

Design and implement automated test frameworks in Go

• Unit, integration, contract, and end-to-end tests
• Async and event-driven workflows (Kafka, NATS)

Build test harnesses for

• gRPC and HTTP APIs
• Multi-service workflows
• Eventual consistency, retries, and failure scenarios

Validate data correctness and consistency across

• Postgres (migrations, indexes, transactional behavior)
• Redis (caching, rate limiting, queues)
• Messaging systems (ordering, retries, DLQs)

Test and harden production behaviors

• Timeouts, retries, idempotency
• Backpressure and recovery
• Concurrency and race conditions
• Add tests from incident retrospectives to prevent regressions

Partner with CI/CD to

• Enforce quality gates
• Reduce flaky tests
• Improve signal-to-noise in failures

Backend Go Engineering (Secondary – ~40%)

• Build and maintain Go microservices powering the platform

(control-plane and data-plane services).

• Design service-to-service communication using:
• gRPC
• HTTP
• event-driven patterns
• Implement features with testability and observability as first-class concerns.

Optimize performance and reliability for

• Postgres queries, indexing, and migrations
• Redis usage patterns

Ship services on Kubernetes

• Docker images
• Deployment configs
• Safe rollouts and operational readiness

Implement platform fundamentals when needed

• authN / authZ
• RBAC concepts
• multi-tenant isolation and boundaries

Frontend QA / Engineering (React.js)

Frontend work here is engineering-grade and directly impacts platform reliability

and security.

Frontend QA / Automation

• Own frontend quality strategy for React applications and embedded widgets.
• Design and implement automated frontend test suites:
• Component tests
• Integration tests
• End-to-end tests (API-driven, not brittle UI-only flows)
• Validate frontend ↔ backend interactions:
• API contracts
• auth flows
• session lifecycle
• error handling and edge cases
• Test security-sensitive frontend behaviors:
• token handling and storage
• CORS and domain restrictions
• rate limiting and abuse scenarios
• multi-tenant boundary enforcement
• Ensure correctness under:
• slow or unreliable networks
• partial backend failures
• retry and reconnect scenarios
• Add regression tests based on:
• production incidents
• bugs
• security findings

Frontend Engineering (React.js)

• Build and maintain React.js applications and embedded widgets.
• Implement frontend features with:
• testability
• observability
• security

as first-class concerns.

• Design predictable and debuggable state management and API layers.
• Integrate frontend with backend services:
• authN / authZ flows
• tenant-aware APIs
• async and real-time updates
• Partner with backend, DevOps, and security teams to reduce frontend-driven incidents.

Must-have

• 3–5+ years of Golang experience in production systems.
• Strong background in QA / SDET for distributed systems.
• Proven experience building automation and test infrastructure in Go.
• Hands-on experience with microservices and async systems.
• Working knowledge of Postgres, Kafka, NATS, Redis.
• Comfortable with Docker and Kubernetes deployments.
• Strong ownership mindset and written communication.

Nice-to-have (Highly Relevant)

• Observability: OpenTelemetry, tracing, metrics, structured logging.
• Load, stress, and chaos testing of distributed systems.
• Kubernetes internals:
• controllers / operators
• admission webhooks
• Experience building:
• internal platforms
• CI/CD pipelines
• developer tooling
• multi-tenant SaaS infrastructure
• Frontend automation with Playwright or Cypress.

Apply

Send

• LinkedIn
• GitHub / code sample
• A short note describing:
• a system you owned
• how you validated its correctness
• what improved (reliability, latency, incidents, throughput, dev velocity)