ALPHA10X
All open roles
TechDoha, Qatar (on-site)

Senior Platform Engineer

The Senior Platform Engineer owns the ground our engineers stand on.

Apply

About this role

ALPHA10X is an award-winning, AI-native Decision Intelligence platform built for private markets - a market projected to exceed $65 trillion in AUM by 2032, but one in which investment decisions remain constrained by fragmented data, subjective judgment and limited predictive infrastructure. At its core is ALPHAcodex, a governed reasoning system that combines data, inference, institutional memory and continuous learning to generate quantitative signals and probabilistic foresight. The platform is designed to improve underwriting and capital allocation over time: each decision becomes institutional memory, strengthening the intelligence applied to subsequent decisions and creating the potential for a compounding advantage in judgment, conviction and investment performance.

Founded in France, ALPHA10X has progressively shifted its center of gravity to the Middle East as the region has become increasingly important to global capital allocation. The company is establishing its global headquarters and principal operating hub in Doha, providing a strategic base for product development, commercial expansion and global growth.

ALPHA10X has raised $25 million in seed capital from prominent investors and academics and completed more than 70 engagements across 11 countries. The company is now entering its next phase of scale, strengthening leadership, accelerating R&D, building its Doha organization and expanding institutional market penetration ahead of a planned Series A financing.

The Senior Platform Engineer owns the ground our engineers stand on.

Reporting to the Head of Platform, you join as the second platform engineer: a hands-on individual contributor working across the full width of the platform. That means the Azure and Kubernetes foundation, the software factory that ships a dozen-plus services to production, the day-to-day developer experience of the engineering team, the security posture of all of it, and the observability that tells us what is actually happening. Increasingly, it also means the tooling that lets AI-assisted development happen inside our software lifecycle rather than around it.

Based in Doha, with the Head of Platform in France, you hold the keys to the whole platform from day one. We promote autonomy and responsibility: you act on the platform for the whole team, wherever they sit, and the role grows as fast as you grow it. This is a senior individual contributor role: you will not manage a team, but you will shape how the engineering team works through the primitives you build, the defaults you set, and the reviews you give.

Over the longer run, as the team grows, the same platform may also need to run as dedicated instances under sovereign hosting constraints. That capability is not on the near-term roadmap, but this role is where it would start.

Breadth is the point. In a given week you might be moving a legacy App Service onto AKS, extending a service template, moving a data store to private networking, shaving minutes off a CI run, wiring tracing through a multi-agent workflow, giving an owner to something that does not have one yet, and writing the runbook so nobody has to figure it out again. We are a small team with a large surface area; we try a lot of things, keep what works, and are honest about what does not.

This is an engineering role. We administer systems, but we are not system administrators: we write the code that runs the platform (tooling, automation, libraries, services) with tests and reviews, the same way any other engineering team ships software. The direction is set; we are hiring someone to own building it.

We are ambitious and pragmatic, both at once. As Donald Knuth put it: “We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil. Yet we should not pass up our opportunities in that critical 3%.” Most of the platform should be boring, conventional, and fast to change. The craft is in recognizing the 3% where it is worth going deep, and going deep there without apology.

In the words of Grady Booch: “The task of the software development team is to engineer the illusion of simplicity.” For a platform team, the illusion is the product. Every engineer should experience sane defaults, a small set of supported paths, and a system that explains itself; the complexity that makes that possible is ours to own, and ours to keep out of their way.

This is an opportunity to build and run the platform beneath a product used to make real investment decisions, as the second platform engineer in the company and one of the first engineers in our Doha office. The role offers rare breadth for an individual contributor (infrastructure, delivery, developer experience, security, observability, and the AI tooling layer, with genuine ownership of each) in a high-velocity, high-growth environment, as part of a team that connects people, capital, and ideas to solve some of the world’s greatest challenges through AI-driven financial solutions.

The successful candidate will be someone who takes initiative, stays curious, and has a finisher’s instinct: they would rather finish the migration than hand off a beautiful design. They will be adaptive and introspective: willing to learn, guide, lead, and follow, with the low ego of someone for whom the outcome matters more than who gets the credit.

Key Responsibilities

  • Platform & Infrastructure: Run and evolve our Azure/AKS platform, GitOps-first, with everything under code. A small set of well-supported service patterns beats supporting everything.
    • Retire the remaining legacy App Service and Function App footprint and establish clean environment boundaries.
    • Provision the stateful layer the product depends on (Elasticsearch, PostgreSQL, Redis, MongoDB) per environment, with sane defaults, so application teams get a database without a ticket.
    • Keep the whole infrastructure under code and reproducible from a clean account.
  • Software Factory & Developer Experience: Own the paved paths so a new service looks like the last one and ships the same way. Remove friction, then measure that you did.
    • Own the service templates, reusable CI workflows, and platform SDK; keep dependency updates automated; and help shape the internal developer portal.
    • Put quality gates in place before merge, and make releases safe and reversible.
    • Find where engineers lose time and remove it.
  • Observability: Make the platform and the AI workloads running on it observable, on the Grafana stack with VictoriaMetrics for metrics and OpenTelemetry for traces. Every engineer should be able to answer “what is actually happening in production?” themselves, with data rather than a guess; the platform team is there for the deep dives.
    • Define SLIs and SLOs for the services that matter.
    • Make alerting wake the right person for the right reason.
    • Give every team the dashboards and runbooks they will actually use.
  • Security: Own the platform’s security posture. We default to minimum blast radius: security is designed in from the start, not added at the end.
    • Private networking across our managed services, and least-privilege identity and access.
    • No long-lived secrets held by humans; per-service keys through a central LLM gateway that fronts every model provider behind one OpenAI-compatible API.
    • Supply-chain controls (image and dependency scanning) and policy-as-code.
  • Reliability & Cost: Keep the platform dependable and affordable under real usage. A service is only finished when its cost and reliability are known and under control.
    • Incident response and post-mortems.
    • Capacity planning and right-sizing.
    • Cloud cost visibility per environment and per workload.
  • AI in the SDLC: Bring AI-assisted development into the lifecycle deliberately: pragmatic, not dogmatic.
    • Agent-friendly repositories: conventions, specs, shared skills, and guardrails.
    • The harness that makes Claude Code and Cursor safe and useful at team scale.
    • A clear-eyed view of what these tools actually deliver versus what they promise.
  • Cross-functional Collaboration: Work closely with the AI, Data, Application, and Solutions teams, wherever they sit, to understand what they are building and what slows them down. Influence comes from what you build and how you review, not from a title.
    • Contribute to code reviews and share practices.
    • Document what you build.
    • Raise the engineering bar through collaboration and example.

What Success Looks Like

Success in this role will be visible in how boring the platform is to operate and how fast the team ships on it. The measure of success is simple: every engineer ships on a platform that is secure, observable, and boring to operate because this person built it.

  • Within the first 30 days, the Senior Platform Engineer will have:
    • been onboarded on our platform, GitOps flow, and observability stack;
    • shipped a first change to production through the paved path; and
    • taken ownership of one open platform initiative, end to end.
  • Within the first 60 days, the Senior Platform Engineer will have:
    • landed, or taken to cut-over readiness, that initiative (a legacy service moved onto AKS, a data store moved to private networking, or a CI pipeline made fast and trusted) and documented the pattern so it is repeatable; and
    • tuned alerting on the components they took over so that every page is actionable.
  • Within the first 6 months, the Senior Platform Engineer will have:
    • become the accountable owner of one platform domain (delivery, observability, or security), with SLOs, runbooks, and cost tracked;
    • made the paved paths the default route for every new service; and
    • made production self-explaining: engineers find their own answers in dashboards and traces, and escalate only the deep dives.

What We Are Looking For

This role requires a combination of hands-on platform engineering; breadth across infrastructure, delivery, and observability; and the discipline to finish. We are looking for someone who:

  • Has a Master’s degree (minimum) in computer science or engineering.
  • Has 7+ years in platform, infrastructure, or backend engineering, including running production Kubernetes on a major cloud. Azure specifics (AKS, Entra ID, private networking) are a strong plus; we will teach them to a solid engineer coming from AWS or GCP.
  • Has run GitOps and infrastructure as code (Terraform, Argo CD, Helm) in production under real load, not just in a tutorial.
  • Has built CI/CD pipelines (GitHub Actions, reusable workflows) that other people depend on, and knows what makes them slow and flaky.
  • Is hands-on with the Grafana stack (Loki, Prometheus-compatible metrics, Alertmanager): instrumenting services and designing dashboards and alerts that people actually use.
  • Writes software, not just configuration: tooling, automation, shared libraries, and the occasional service, with tests, reviews, and the discipline of a product codebase. Language matters less than the habit; you will pick up ours.
  • Takes a problem end to end, including the unglamorous parts, and closes it.
  • Is comfortable moving between several systems in a week, and would rather have breadth than a single specialty.
  • Communicates clearly and concisely, and can explain a trade-off to an engineer, a data scientist, and a product manager in the same meeting.
  • Reaches for sane defaults and a small set of supported paths before adding knobs.
  • Makes the people around them better through example, without needing authority to do it.

Experience with OpenTelemetry, self-hosted CI runners on Kubernetes, running stateful workloads on Kubernetes (Elasticsearch/ECK, PostgreSQL, MongoDB), LLM gateways and tracing (LiteLLM, LangSmith/Langfuse), Cloudflare, FinOps, or agentic coding workflows at team scale would be valuable. However, a track record of platforms that other engineers ship on, and that stayed boring in production, matters more than any particular tool.

Our Tech Stack

We run on Azure and build on CNCF and open-source projects wherever they fit, leaning toward self-hosted open source over managed black boxes when the trade-off allows. What you will work with day to day:

  • Azure: AKS, Entra ID, PostgreSQL, Redis, Azure OpenAI
  • Kubernetes, Argo CD, Helm, Terraform, Traefik, cert-manager
  • GitHub, GitHub Actions, Renovate
  • Grafana stack (Loki, Alloy, Alertmanager), VictoriaMetrics, OpenTelemetry
  • Elasticsearch, MongoDB
  • LLM gateway (OpenAI-compatible API), LangSmith, Cloudflare
  • Claude Code, Cursor

Apply by sending your CV to hr@alpha10x.com

Apply
Other open roles
All open roles