Job Title: Senior Backend Engineer
Location: Dubai, UAE · on-site
Experience Required: 6+ years
We're hiring a Senior Backend Engineer to design and build significant parts of our second-generation platform: the services behind several business-critical products, where transactions, money and third-party integrations have to be right the first time. You'll own services end to end, set the bar for how the team builds, and shape how we work with coding agents day to day.
About us
We are an IT company based in the Gulf, building and operating several software products for business customers across the Middle East. Our platforms are multi-tenant, transactional and heavily integrated: they connect to our customers' existing systems, process payments through regional providers, and give operators live visibility into what is happening in their business.
We are rebuilding our core platform as a set of services and expanding the product portfolio over the next two years. The roadmap is mapped; we need people who can carry big pieces of it. We'll tell you much more about the products themselves during the interview process.
The stack you'll work in
Services: Python 3.13, FastAPI, SQLAlchemy 2 (async, asyncpg), Alembic, Pydantic. One Go 1.26 service (Gin, sqlc, hexagonal architecture, documented with ADRs) for payments, heading to production.
Data: PostgreSQL with a database per service, Row-Level Security, TimescaleDB for analytics.
Async & messaging: Celery on Redis, RabbitMQ (aio-pika) with a transactional outbox and a versioned, CI-checked event contract shared through an internal library
Edge & platform: Traefik with ForwardAuth over an OIDC identity provider, scoped RBAC, multi issuer JWTs (we white-label).
Operations: Docker, GitHub Actions, a self-hosted PaaS, structlog, Prometheus, Grafana, Sentry. pytest, ruff, mypy, uv.
Around the edges: a Django/React first-generation platform still in production, a .NET 8 on-premises integration agent deployed at customer sites, and a native Android app.
What you'll do
Design and build backend services in Python with clean boundaries and explicit contracts between them, and help take the Go payment service from pre-production to live.
Own features end to end: API design, implementation, tests, migrations, rollout, and the dashboards and alerts that prove the feature is healthy.
Solve the hard parts of distributed systems: idempotent writes against third-party APIs that time out mid-write, at-least-once callbacks, transactional outbox, retry ladders, dead-lettering, and reconciliation when the two sides disagree.
Model and evolve multi-tenant PostgreSQL schemas you can migrate safely against live tenant data, with Row-Level Security as a real control rather than decoration.
Build anti-corruption layers around partner APIs that are inconsistent, slow, and occasionally wrong: normalise their behaviour behind a stable adapter interface, extend what we can push to them as well as pull, and surface honest per-partner capability flags to the product.
Get money right: minor-unit money across 2- and 3-decimal currencies (AED, SAR, KWD, BHD, OMR), tax, fees, apportionment, refunds, and regional e-invoicing compliance.
Harden the platform: per-service secrets, RLS everywhere, an event bus that reaches every service, and realtime delivery (SSE) replacing polling.
Ship AI in the product: LLM-backed features such as content enrichment and classification with human review, conversational interfaces, and anomaly detection in reconciliation, with evals, guardrails, and cost and latency budgets.
Lead incident response for what you own, and write the honest post-mortem.
Raise the bar: review, ADRs, mentoring mid-level engineers, and shaping how the team uses coding agents.
How we build
We treat coding agents as part of the team, not a novelty. This is what the software development lifecycle looks like here, and what we'll expect you to be fluent in:
Spec first. Work starts as a written plan: the contract, the edge cases, the failure modes, and the tests that prove them. Agents such as Claude Code implement against the plan; the engineer owns the plan and the review.
The repo is the prompt. Every service carries agent-facing documentation: CLAUDE.md or AGENTS.md , ADRs, and a domain glossary, kept current so that an agent or a new hire lands in the right place. When an agent keeps making the same mistake, we fix the docs, not just the diff.
Review it like it came from a stranger. Agent output ships only after a human has read it with the rigour of a junior's pull request: does it match the spec, does it handle the failure path, did it invent a partner API response.
Tests are the contract. Agents write and run tests too. Failure-path tests are what make agent speed safe on a money path.
Judgement about where not to. Payment writes, tenant isolation and cryptography get slower, human-led work. Knowing the difference is part of the job.
Core requirements
Production ownership
You've carried real systems in production, not handed them off. You've been on-call, debugged a live incident with users affected, and written the write-up afterwards. You ask "how will I know when this breaks?" before "how do I build this?"
Attention to detail
On a transactional platform that moves money, an off-by-one on tax, a duplicated write on a retry, or a missing tenant filter is an incident, not a cosmetic defect. You read the edge cases before writing the happy path, verify what a partner API actually returns instead of trusting its docs, and notice when two numbers that should agree don't.
Engineering depth
- 6+ years building and running production backends, with real time on distributed or service-oriented systems.
- Strong Python and a modern async framework (FastAPI or similar). Equivalent depth in Go, Java, C# or TypeScript plus real willingness to work in Python is fine.
- PostgreSQL: schema design, indexes and query plans, migrations you'd run on a Friday.
- Async processing and message brokers (Celery, RabbitMQ, Kafka, SQS) and Redis for caching, locking or queuing.
- REST API design with versioning and backward compatibility; gRPC or event-driven design a plus.
- Docker, CI/CD, and enough operational fluency to debug from logs, metrics and traces.
- Tests you actually trust, covering the failure paths, not just the happy one.
- Clean, layered code. You've seen business logic and infrastructure get tangled and you design to avoid it.
AI-native engineering
- You use coding agents daily and can show your workflow: how you write the spec, how you constrain the agent, how you verify the output, and where you stop trusting it.
- You've written agent-facing documentation for a codebase (a CLAUDE.md , AGENTS.md , cursor rules or equivalent) and can explain what made it effective.
- You've designed or shipped at least one LLM-backed feature or agentic pipeline in production, or can demonstrate equivalent depth: prompt and context design, tool use and structured outputs, evals, guardrails, fallbacks, cost and latency budgets, and handling of personal data.
- You can articulate where agent-generated code is and isn't acceptable on a money path, and you've caught a plausible-looking wrong answer from a model in real work.
Nice to have
- Go in production; Clean Architecture or DDD in a real codebase.
- Multi-tenant SaaS, with Row-Level Security or an equivalent isolation model.
- Payments, fintech, or another domain where numbers had to be exactly right.
- Deep third-party integration work: adapters over inconsistent partner APIs, on-premises connectors, reconciliation.
- Kubernetes, infrastructure as code, AWS.
- Django (our first-generation platform is Django and still earns revenue).
- .NET or Windows services (our on-premises integration agent).
- Arabic, or experience shipping to Gulf markets.
What the first six months could look like
- Take ownership of one live service, its on-call rotation, and its dashboards.
- Land the payment-service cutover work that fixes 3-decimal currency handling platform-wide.
- Wire the on-premises agent's real capabilities into the cloud so a class of customers gets features they are currently denied.
- Design and ship the first outbound event stream from our integration core, unblocking realtime and analytics.
- Write the ADR and the agent-facing docs for the first service you touch, and see a mid-level engineer ship against them
Job Type: Full-time
Application Question(s):
- What is your current monthly salary (AED)?
- What is your expected monthly salary (AED)?
- Are you available to join immediately? (If not, mention notice period)
Education:
- Bachelor's (Preferred)
Experience:
- Back-end development: 6 years (Required)
Work Location: In person