Product Engineer

Location: HCM/HN

Job Summary

We are hiring a Product Engineer - an engineer accountable for outcomes, not output.

We do not measure engineers by tickets closed or lines shipped. We measure them by whether the thing they built actually solved the user's problem.

That means you will be expected to question requirements before building them, own a feature from ambiguity through to production behaviour, and stay attached to it after release - watching the metrics, the logs, and the support tickets.

You will work with Product Managers, designers, and business stakeholders based in different countries and timezones. Overlap hours are limited by design, so clear communication and the ability to move a decision forward asynchronously - without waiting for a meeting - matter as much as your engineering skill.

This is a deeply technical role with an AI-first mindset. AI coding agents are the default way we build here - you will spend more of your day designing architecture, steering agents, and reviewing generated code than typing implementations by hand. We expect fluency with spec-driven development, reusable agent skills, and context engineering, not occasional autocomplete use.

Our backend is built as Go microservices running on Kubernetes, and you will be a senior voice in shaping how those services are designed and operated.

Which is exactly why fundamentals and best practices matter more, not less, so you will be held to a high bar on SOLID, Clean Architecture, design patterns, distributed system design, relational data modelling, and automation testing: these are working knowledge, not résumé keywords, and you should expect to defend your choices reasonably in code review and in the interview.

You remain the author of record for everything that lands in main. The agent wrote it is never an

acceptable explanation for a defect.

Key Responsibilities

• Own the outcome. Take a business problem from vague to shipped to measured. Define what

success looks like with your Product Manager, instrument for it, and act on what the data says -

including rolling back or rewriting your own work when the numbers disagree with the plan.

• Find the problem, not just the solution. Interrogate requirements before implementing them. Surface the cheaper path, the edge case nobody scoped, and the feature that shouldn't be built. Say so early and in writing.

• Collaborate across borders and timezones. Partner directly with Product Managers, designers, QA, and business stakeholders distributed across multiple countries. Write decisions down, keep specs and PR descriptions self-explanatory, unblock people in other timezones, and run the occasional early or late call when the others need it.

• Architect and build services and APIs. Design RESTful (and where appropriate, event-driven or

gRPC) services applying SOLID, Clean/Hexagonal Architecture, and design patterns deliberately - with a clear justification for the boundaries you draw. Design normalized, indexed, migration-safe relational schemas that hold up under real query load. Architecture is the part an agent cannot infer for you: you set the boundaries and the contracts, then let agents fill them in.

• Design for distribution. Make grounded calls on monolith vs. microservices, and design the

microservices architecture yourself - service boundaries, contracts, and failure isolation. Build services in Go that satisfy 12-factor principles - externalized config, stateless processes, disposability, dev/prod parity - and containerize and deploy them on Kubernetes.

• Automate the safety net. Own automated testing for what you build: unit, integration, contract, and end-to-end where it earns its keep. Tests ship in the same PR as the code, not in a follow-up ticket. A bug fix without a reproducing test is not a fix. In an AI-first workflow the test suite is the specification - it is what makes agent-generated change safe to merge at speed.

• Work AI-first, and hold the line on quality. Drive delivery with coding agents, know your acceptance criteria first, let agents execute, then review hard. Build and maintain reusable agent skills, project instructions, and guardrails so the whole team gains leverage - not just your own throughput. Reject output that is merely plausible: over-abstracted layers, duplicated logic, silently swallowed errors, tests that assert nothing. Never merge code you cannot explain line by line.

• Run what you ship. Instrument services with structured logging, metrics, and tracing. Debug

production incidents, write the postmortem, and close the loop with a fix that prevents recurrence.

• Raise the team's bar. Review peers PRs substantively, document trade-offs and decisions, and

mentor on fundamentals and on responsible AI-assisted workflows.

Job Requirements

• 5-7 years building and operating production backend services - and you can walk through a

system you designed, why you designed it that way, and what you'd change now.

• Microservices design: you have personally designed (not just worked in) a microservices architecture in production. You can explain how you drew the service boundaries, chose inter-service communication (sync vs. async), handled failure isolation and data ownership, and what you would do differently. Plus honest judgment on when a monolith is the correct answer.

• Golang: hands-on, production Go development, with at least 4-6 months of recent, active use (within the last 12 months) building real services - not side projects or tutorials.

• Kubernetes: strong working experience with community (open-source) Kubernetes - deployments, services, config/secrets, health probes, resource limits - and confident with Docker.

• Deep, demonstrable command of software design fundamentals: OOP, SOLID, Clean Architecture, and design patterns. You will be asked to critique a design and explain what breaks at scale. This is the non-negotiable core of the role - in an AI-first team, fundamentals are the review capability that keeps agent velocity from becoming agent debt.

• Strong RESTful API design: resource modelling, versioning, idempotency, pagination, error contracts, authentication/authorization.

• Strong relational database design (PostgreSQL/MySQL): normalization and when to break it, indexing strategy, transactions and isolation levels, query analysis, safe schema migrations.

• 12-factor apps: configuration and secrets management, stateless processes, disposability, dev/prod parity.

• Automation testing discipline: you write tests first or alongside, understand the test pyramid, and use test doubles without mocking away the thing under test. You treat coverage as a floor for confidence, never as a number to satisfy - and you can tell a genuine regression test from an agent-generated one that asserts nothing.

• An AI-first way of working, already in your hands: real production experience with Claude Code, Cursor, Copilot, or equivalent - including spec/context engineering, agent skills or custom commands, and a disciplined self-review process before any PR. You should be able to describe a time an agent produced plausible-but-wrong code, how you caught it, and which fundamental (a design principle, a data-model rule, a failing test) let you catch it.

• Product mindset with real ownership instincts: comfortable with ambiguity, able to talk to non-engineers about trade-offs in their language, and biased toward shipping something small to learn rather than debating something large.

• Effective asynchronous, cross-cultural collaboration: professional written English, the discipline to

document context for people who are asleep when you're working, and comfort operating with

stakeholders in several countries and time zones.

• Working frontend ability - React, Next.js, or Vue - enough to build and ship a full user-facing slice

yourself.

Nice to Have

• gRPC and HTTP/2, including streaming and Server-Sent Events (SSE) for real-time and AI-streaming interfaces.

• ReactJS / NextJS at depth - SSR/RSC, routing, data fetching, performance.

• CI/CD pipeline ownership (GitHub Actions, GitLab CI, or similar) including automated quality and security gates.

• Infrastructure as Code - Terraform, Pulumi, or Helm.

• Service observability and SRE practice - OpenTelemetry, APM (Datadog / New Relic / Grafana stack), SLOs and error budgets, on-call and incident response.

• Message queues, background job processing, and event-driven architectures.

• SaaS products, media streaming (HLS/M3U8), or prior experience in a distributed international team.