The Role

Backend engineering at TrueAi means owning the platform's spine. The architecture is documented; a senior engineer who knows the stack is productive within two to four weeks. TrueAi does not have product managers. You form your own view of the work, write it down, and defend it.

What the Work Looks Like

A day might span any of the following. Debating an architectural decision in writing before any code is committed, then sitting with that decision for two days before opening a pull request. Reading the existing codebase carefully enough to extend it without rebuilding it. Tracing a performance issue through three layers of abstraction to find the query plan that broke under realistic load. Designing the access control model for a new module so that the wrong person cannot ever see the wrong row, even by accident. Writing the schema migration that moves a million rows without taking the API down. Sitting with the founding team to argue about whether a new feature earns its place in the platform or whether it should wait. Reviewing your own work three times before showing it to anyone else, and then defending it under scrutiny. Travelling to a client site to handle the technical conversation in the room.

The work compounds. Every architectural decision you make becomes part of the platform's inheritance. The disciplines you set become the disciplines the next engineer inherits.

What You Will Own

Three layers of work:

Hardening. Making the platform safe to put in front of clients whose data and trust are not recoverable.

Extension. Building the capabilities that let the platform handle a growing surface without losing coherence.

Preparation. Laying the groundwork for what comes next.

At a high level:

• The backend codebase and its evolution.
• Security posture: data isolation, access control, auditability.
• Performance and reliability against realistic load.
• The API surface, including its clarity and resistance to misuse.
• Observability that makes the platform legible at any moment.
• Engineering disciplines for testing, review, and documentation.
• Occasional travel to client sites where engineering input is needed in the room.

Tools

A modern async Python stack:

• Python 3.12+
• FastAPI, Pydantic v2, Uvicorn
• PostgreSQL with SQLAlchemy 2.x async, asyncpg, Alembic
• Redis with ARQ for caching and tasks
• PyJWT, passlib with bcrypt, OAuth2, RBAC
• Structlog, Sentry, OpenTelemetry, Prometheus
• pytest, pytest-asyncio, httpx
• Ruff, Hatchling
• Docker, Nginx, Linux
• Git, GitHub, GitHub Actions

Frontend context: TypeScript, React, Vite, Tailwind.

Familiarity with this family of tools is expected; TrueAi is not where you learn them.

What You Must Bring

Experience

• Production backend engineering, the majority on Python.
• Hands-on experience with FastAPI or an equivalent modern async Python framework.
• Production PostgreSQL: complex queries, performance tuning, schema migrations.
• SQLAlchemy 2.x async, not only SQLAlchemy classic.
• REST APIs serving production traffic.

Character

Defensive instincts. You write code as if the worst plausible thing will happen.

Quiet rigour. You hold your own standard without supervision and review your own work before offering it to anyone else.

Reading before writing. You understand a codebase before you extend it.

Written thinking. You document your reasoning and write before you build.

Proposals, not escalations. You arrive with a solution and the trade-offs you considered.

Seriousness. The software is consequential. You bring that understanding to your daily work.

Conduct

• Full-time, on-site in Khobar, five days a week.
• Written and spoken English. Arabic is a plus, not a requirement.
• Willingness to travel occasionally to client sites.
• Alignment with TrueAi's professional standards, including workplace appearance and the conduct expected of someone representing the Company in client environments.

What Would Set You Apart

• Multi-tenant data isolation as a hard requirement, not an afterthought.
• Platforms handling sensitive data under regulatory oversight.
• Structured data modelling, ontologies, or semantic systems.
• Early-engineer experience where your standards became the inherited standards.
• Production operations beyond writing code: Docker, CI/CD, Linux.
• Meaningful contributions to open-source Python infrastructure, particularly FastAPI, SQLAlchemy, or Pydantic.
• A public body of work (GitHub, side projects, technical writing) that shows how you think when no one is paying you to think.
• Fluent in the current AI landscape as a technical practitioner. You understand the difference between models, you have worked with agents and prompting as engineering tools, and you treat AI as a force multiplier on your thinking, not a replacement for it.

What This Role Is Not

• A machine-learning or applied-AI research role. This is backend platform work.
• A remote role. TrueAi is on-site. This is not negotiable.
• A role where someone else reviews your work before you do.
• A role with a product roadmap handed to you. You participate in shaping the work.
• A comfortable seat.

How We Work

Four expectations:

Architecture before implementation. Hard problems are thought about in writing before any code is committed.

Self-review before external review. Shipping work that has not been self-reviewed is a professional standard failure.

Reading before writing. Context is not optional.

Proposals, not escalations. When the path is unclear, think harder, write down the options, bring a recommendation.

You receive the equipment, the workspace, and the time the work requires. The standards above are expected without reminder.