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 accurate 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.

📌 Sr. Backend Engineer - Python & FastAPI (Mumbai)
🏢 Amunra
📍 Mumbai