About The Role
We are hiring a Product Engineer who takes ownership of outcomes. Success is measured by whether what you build solves the user's problem.
You will question requirements, own features from initial ambiguity through production, and stay involved after release by monitoring metrics, logs, and support feedback.
You will collaborate with Product Managers,
designers, QA, and business stakeholders across countries and time zones. With limited overlap hours, clear written communication and the ability to move decisions forward asynchronously are essential.
This is a deeply technical role with an AI-first approach. Coding agents are central to our development workflow. You will design architecture, guide agents, and review generated code, using spec-driven development, reusable agent skills, and context engineering.
Our backend consists of Go microservices running on Kubernetes. You will help shape how these services are designed and operated, applying strong engineering fundamentals and taking full responsibility for the code you ship.
Key Responsibilities
Own Product Outcomes
Take business problems from discovery through delivery and measurement.
Define success with your Product Manager, instrument features, and act on the results.
Roll back or revise your work when the data shows that a different approach is needed.
Challenge requirements early, identify simpler alternatives, surface overlooked edge cases, and explain when a feature should not be built.
Collaborate Across Countries and Time Zones
Partner directly with Product Managers, designers, QA, and business stakeholders.
Document decisions, maintain clear specifications, and write self-explanatory PR descriptions.
Unblock colleagues asynchronously and join occasional early or late calls when needed.
Design and Build Services
Design RESTful APIs and, where appropriate, event-driven or gRPC services.
Apply SOLID principles, Clean/Hexagonal Architecture, and design patterns with clear justification.
Design relational schemas with appropriate normalization, indexing, and safe migrations.
Define architecture boundaries and contracts before guiding agents through implementation.
Design for Distributed Systems
Make informed decisions about monoliths versus microservices.
Own service boundaries, inter-service contracts, data ownership, and failure isolation.
Build production Go services following 12-factor principles, including externalized configuration, stateless processes, disposability, and development/production parity.
Containerize services with Docker and deploy them on Kubernetes.
Build Automated Safety Nets
Own unit, integration, contract, and end-to-end testing where appropriate.
Ship tests in the same PR as the implementation.
Include a reproducing regression test with every bug fix.
Use the test suite to validate agent-generated changes and support safe delivery.
Work AI-First While Maintaining Quality
Define acceptance criteria, guide coding agents, and critically review their output.
Build reusable agent skills, project instructions, and guardrails for the team.
Identify and reject unnecessary abstractions, duplicated logic, swallowed errors, and ineffective tests.
Take responsibility for every change you merge and be able to explain the code.
Operate and Improve Production Services
Implement structured logging, metrics, and tracing.
Investigate production incidents, write postmortems, and deliver fixes that prevent recurrence.
Review peers' PRs, document trade-offs, and mentor teammates on engineering fundamentals and responsible AI-assisted development.
Requirements
Backend Engineering and Architecture
5-7 years of experience building and operating production backend services.
Ability to explain a system you designed, the decisions behind it, and what you would improve today.
Personal ownership of a production microservices architecture, including:
Service boundaries and data ownership.
Synchronous versus asynchronous communication.
Failure isolation.
Trade-offs and situations where a monolith is more appropriate.
Hands-on production Go experience, including at least 4-6 months of recent, active use within the last 12 months building real services.
Strong working experience with community/open-source Kubernetes, including deployments, services, configuration, secrets, health probes, and resource limits.
Confidence working with Docker.
Engineering Fundamentals
Deep practical knowledge of OOP, SOLID, Clean Architecture, and design patterns.
Ability to critique designs, justify architectural choices, and explain potential issues at scale.
Strong RESTful API design skills, including resource modelling, versioning, idempotency, pagination, error contracts, and authentication/authorization.
Strong relational database design skills with PostgreSQL or MySQL, including normalization, indexing, transactions, isolation levels, query analysis, and safe schema migrations.
Practical understanding of 12-factor application principles.
Automated Testing
Discipline to write tests before or alongside implementation.
Understanding of the test pyramid and appropriate use of test doubles.
Ability to assess whether tests provide meaningful regression protection.
A focus on reliable behaviour and confidence in changes, beyond coverage percentages.
AI-Assisted Development
Production experience with Claude Code, Cursor, Copilot, or equivalent tools.
Practical experience with spec/context engineering, agent skills or custom commands, and disciplined self-review before submitting PRs.
Ability to describe a case where an agent produced plausible but incorrect code, how you identified it, and which engineering principle or test helped you catch it.
Product Ownership and Collaboration
Comfort working with ambiguity and taking ownership of user outcomes.
Ability to explain technical trade-offs clearly to non-engineers.
A preference for shipping small increments to learn and improve.
Professional written English and effective asynchronous, cross-cultural communication.
Discipline to document context for colleagues working in other time zones.
Working frontend skills in React, [protected info], or Vue, sufficient to independently build and ship a complete user-facing feature.
Nice to Have
gRPC and HTTP/2, including streaming and Server-Sent Events (SSE).
Advanced React/[protected info] experience, including SSR/RSC, routing, data fetching, and performance optimization.
CI/CD pipeline ownership using GitHub Actions, GitLab CI, or similar tools, including automated quality and security gates.
Infrastructure as Code with Terraform, Pulumi, or Helm.
Observability and SRE experience with OpenTelemetry, Datadog, New Relic, or the Grafana stack.
Experience with SLOs, error budgets, on-call support, and incident response.
Message queues, background job processing, and event-driven architectures.
Experience with SaaS products, media streaming (HLS/M3U8), or distributed international teams.