Backend Engineer — AI-Driven Development (CTRM Platform)

We build software by directing coding agents. Most of the code in this project is written by Claude Code. The engineer's job is everything that decides whether that code is correct: the architecture, the service boundaries, specifications precise enough to be implemented without guesswork, and review of every line that ships. We want engineers for whom AI-driven development is already the primary way they work — not a side experiment, not IDE autocomplete. We are explicitly not looking for vibe coders.

The product

We are building a new CTRM platform (Commodity Trading & Risk Management) for a physical oil-products trader: the full deal lifecycle from contract to settlement — pricing against market formulas, cost aggregation, invoicing, logistics, inventory, hedging.

Stack

Node.js and Python on the backend, React on the frontend, Postgres, Docker, CI/CD.

The role

You are an engineer, not an analyst. Business analysts own the process descriptions and hand you specified requirements. You own turning them into working software.

In practice that means: reading a specification closely enough to find the holes in it, deciding how it decomposes into services and data models, writing task briefs precise enough for an agent to implement, and then reviewing, testing and refactoring what comes back. You are the reviewer of record for everything you ship, regardless of who or what produced it.

You do need to understand what you are building. Not as a domain expert — but you cannot review a settlement calculation you don't follow, and you will be expected to ask the analyst the awkward question rather than implement an ambiguity.

Day to day

• Design services, data models, APIs and transactional boundaries from specified requirements
• Translate requirements into agent-executable task briefs — small enough to verify, large enough to be worth delegating
• Own and evolve the project's agent context: `CLAUDE.md`, coding conventions, architectural guardrails, test policy
• Review every diff seriously: data model, transaction and concurrency semantics, error handling, migrations, security, performance
• Write and maintain tests that pin real behaviour — especially around money, rounding, dates, and state machines
• Refactor aggressively when generated code is correct in isolation but wrong for the system
• Ship in two-week sprints against a defined Definition of Ready and Definition of Done
  

What we expect

• 7+ years building and operating production backend systems
• AI-driven development as your actual workflow.
• You have shipped meaningful production features by directing coding agents, and can talk in detail about how you structure context, decompose tasks, control cost, and verify output
• Domain modelling, relational data design, transaction and consistency semantics, idempotency, concurrency, API design, testing strategy, refactoring discipline. You can explain *why* a rule exists, not just that a linter enforces it
• You can read, debug and reason about code you did not write — quickly, in an unfamiliar codebase
• Strong Node.js and/or Python, solid SQL, comfortable with Docker and CI/CD
• Willingness to engage with complex financial and logistics logic instead of routing around it
• Strong Git, code review, and Agile delivery habits
  
• Business proficiency in Russian language

How to apply

Share your CV plus an answer to two of the following questions:

• Show us a real specification or task brief you wrote for a coding agent, and the code it produced. What did you change after review, and why?
• Describe a time an agent produced code that passed its tests but was wrong. How did you catch it, and what did you change in your process afterwards?
• What is in your `CLAUDE.md` (or equivalent agent rules file)? Pick three rules and explain why each is there.
• Which parts of a system do you refuse to delegate to an agent, and why?

What we offer

• A serious, unsolved domain problem rather than another CRUD product
• Real autonomy over architecture and process, on a team that treats AI-driven engineering as a discipline to be built rather than a shortcut
• Generous AI tooling budget — frontier models are a working expense, not a perk
• Competitive compensation discussed individually