• 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 normalised, 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. Build services that satisfy 12-factor principles - externalised config, stateless processes, disposability, dev/prod parity - and containerise them for Docker/Kubernetes deployment.
• 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.

• 3+ 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.
• 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/authorisation.
• Strong relational database design (PostgreSQL/MySQL): normalisation and when to break it, indexing strategy, transactions and isolation levels, query analysis, safe schema migrations.
• Microservices and 12-factor apps: service boundaries, inter-service communication, failure isolation, configuration and secrets management - plus honest judgment on when a monolith is the correct answer.
• 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.
• Containerisation: confident with Docker; working knowledge of Kubernetes (deployments, services, config/secrets, health probes, resource limits).
• 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 timezones.
• Working frontend ability - React, Next.js, or Vue - enough to build and ship a full user-facing slice yourself.
•  

Nice to Have

• Golang - our preferred backend language for new services.
• 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.