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

Overview

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)