Sr. Backend Engineer - Python & FastAPI

Role Overview

We are hiring a hands-on Senior Backend Engineer to design, build, deploy and operate the three interfaces through which clients access our factor library: a REST API, real-time WebSocket data streams, and an MCP server for AI applications.

You will own service architecture, library integration, real-time data delivery, authentication, client-specific access controls, licensing enforcement, rate limiting, documentation and production reliability. You will work closely with the factor-library team to turn its capabilities into secure, consistent and easy-to-use interfaces.

Python is the primary backend language and FastAPI the primary framework. This is an individual-contributor role with end-to-end ownership: you deploy, run and support what you build.

Key Responsibilities

REST API Development

• Build and maintain production REST APIs in Python using FastAPI.
• Define request and response schemas, input validation, error handling, HTTP semantics and interface versioning.
• Publish and maintain accurate OpenAPI specifications.
• Build a shared integration layer so the REST API, WebSocket streams and MCP server behave consistently.
• Maintain backward compatibility as the factor library and client interfaces evolve.

Real-Time Data Streaming

• Design and build WebSocket services in Python that stream factor values and related data to clients in real time.
• Manage connection lifecycle, subscriptions, heartbeats, reconnection and backpressure from slow consumers.
• Authenticate every WebSocket connection and enforce client entitlements on every subscription.
• Scale streaming fan-out across instances using Redis pub/sub or a message broker.

MCP Server Development

• Build an MCP server with the Python SDK that exposes factor-library capabilities to AI applications as tools and resources.
• Write precise tool descriptions and structured input and output schemas so AI clients invoke tools correctly.
• Implement remote connectivity and authentication, and test against compatible MCP clients.

Concurrency and Computational Workloads

• Use asyncio for I/O-bound work and keep event loops non-blocking under high concurrency.
• Run CPU-intensive factor computations in separate processes via multiprocessing or process pools.
• Run long or heavy jobs through distributed task queues such as Celery, RQ, Arq or Dramatiq, with timeouts, retries and resource limits.

Security, Access Control and Rate Limiting

• Implement authentication using OAuth 2.0, token validation and API keys, with secure secret management.
• Implement organisation-level authorisation and client-specific access controls so each client reaches only its licensed factors, datasets and features.
• Enforce licensing and entitlements consistently across REST endpoints, WebSocket subscriptions and MCP tools.
• Implement per-client rate limiting and usage quotas.
• Implement audit logging and protect sensitive information.

Production Deployment and Operations

• Containerise services with Docker and independently deploy them to production cloud and Linux environments.
• Own CI/CD pipelines, releases and rollback procedures.
• Implement health checks, structured logging, metrics, monitoring and alerting.
• Write automated pytest suites covering library integration, interface behaviour, streaming, permissions, rate limits and failure scenarios.
• Diagnose production incidents and improve reliability, latency and operating cost.
• Maintain runbooks and troubleshooting procedures.

Developer Experience

• Produce API documentation, WebSocket protocol documentation, MCP tool descriptions, integration guides and working examples.
• Document supported inputs, outputs, execution constraints and error conditions with the factor-library team.
• Support client onboarding and resolve integration issues.
• Provide Python client utilities or a lightweight SDK where they simplify adoption.

Must-Have Requirements

• 4+ years of hands-on experience building production REST APIs with Python and FastAPI.
• Hands-on experience implementing asynchronous programming, multiprocessing or distributed task queues for high-concurrency or CPU-intensive Python workloads.
• Independently deployed and maintained Dockerized Python backend services in a production cloud or Linux environment.
• Implemented authentication, authorisation, client-specific access controls and rate limiting for production APIs.
• Strong production Python: type hints, exception handling, dependency management and Pydantic-based validation.
• Automated testing with pytest, including integration tests, permission checks and failure handling.
• Observability in production: logs, metrics, alerts and incident diagnosis.
• Git, code review, CI/CD and controlled releases.
• Ownership of customer-facing APIs from design through deployment and ongoing operation, including supporting external developers.
• Clear written communication and the ability to explain technical trade-offs.

Preferred Requirements

• Built real-time data streaming services using WebSockets in Python.
• Built MCP (Model Context Protocol) servers that expose custom Python tools or functions to AI applications.
• AI tool calling, structured outputs and permission-aware execution.
• PostgreSQL for client accounts, licensing configuration and service metadata.
• Redis, pub/sub and background workers.
• Building Python SDKs or other developer-facing libraries.
• Background in analytical software, financial technology or institutional platforms.