Senior Backend Engineer (Python)

Supero | Platform Engineering | Remote - Bengaluru | 5+ years

Role & Responsibilities

- Own backend services and platform capabilities end to end - from design document and data model through implementation, migrations, tests, deployment, monitoring, and incident follow-up.
- Design and maintain transactional services for workflows such as orders, payments, inventory reservations, subscriptions, approvals, e-signature, and ledger-style operations.
- Build state machines that remain correct under retries and concurrency, with explicit transition guards, idempotency, and clean saga compensation when multi-step operations partially fail.
- Develop and evolve Python backend services and APIs that sit underneath generated applications and are reused across many customer systems.
- Protect platform invariants including hard tenant isolation, role- and field-level access control, owner scoping, and consistent enforcement across every read and write path.
- Design APIs and service contracts that are safe to retry, observable in production, and explicit about failure states rather than relying only on happy-path behavior.
- Work with relational and non-relational data stores and integrations, including customer databases and warehouses, while preserving tenancy, authorization, and cost controls.
- Contribute to Supero's MCP and application-development surfaces so external AI agents and editors can safely drive platform capabilities.
- Write high-signal automated tests that prove specific behaviors: invalid transitions, duplicate requests, partial failures, cross-tenant isolation, permissions, and recovery paths.
- Write design documents and RCAs before or alongside code, review other engineers' designs, and participate directly in debugging and production incidents.
- Ship frequently behind appropriate safeguards such as reviews and feature flags, while maintaining correctness across a platform on which other production applications depend.

Preferred Candidate Profile

- 5+ years of professional backend or platform engineering experience, with substantial production experience in Python.
- Strong understanding of transactional systems, state machines, concurrency, idempotency, retries, failure recovery, and distributed-system trade-offs.
- Experience designing production APIs and backend services, ideally using Python frameworks such as FastAPI or comparable service frameworks.
- Strong SQL and data-modeling skills, including practical experience with relational databases such as PostgreSQL, MySQL, or similar systems.
- Comfortable reasoning about multi-tenancy, authorization, RBAC, data isolation, security boundaries, and how these guarantees can fail in real systems.
- Has owned production services beyond implementation: migrations, testing, observability, deployment, incidents, and post-incident corrective work.
- Can identify edge cases and invariants before coding and explain why a design remains correct when requests are duplicated, reordered, retried, or partially fail.
- Strong written communication. You can write a concise design proposal, challenge assumptions constructively, and document an incident clearly.
- Comfortable working in a remote team across India and the US with a bounded overlap window and an otherwise documentation-first workflow.

Nice to Have

- Experience with saga patterns,



workflow engines, payment/order lifecycles, inventory reservation, subscription systems, ledgers, or other transaction-heavy domains.
- Experience with Kubernetes, cloud infrastructure, event streaming/Kafka, or distributed service architectures.
- Experience building developer platforms, internal platforms, SDKs, code-generation systems, or products used by other engineers.
- Experience with database and warehouse integrations such as PostgreSQL, MySQL, SQL Server, Oracle, MongoDB, Snowflake, BigQuery, or similar systems.
- Experience with LLM-assisted engineering, MCP, AI agents, or building safe tool surfaces that allow agents to interact with production systems.

What You Would Work On Supero's backend is not just CRUD. Generated applications can inherit transactional lifecycles for orders, payments, inventory, subscriptions, approvals and other workflows. Those lifecycles have to remain correct when two requests arrive together, when a client retries, or when step three of a five-step operation fails.

- State machines with guarded transitions and explicit invalid-state behavior.
- Idempotent operations that prevent duplicate side effects such as double checkout or double charging.
- Saga compensation and recovery for multi-step workflows.
- Hard tenant isolation and role/field-level authorization enforced server-side.
- Transactional services, workflows, connectors, APIs, SDKs, and MCP-accessible platform capabilities.
- Tests that prove the invariants rather than merely proving that an endpoint returned an error.

How We Work

- Whole problems, not ticket queues: you own the design, code, migration, tests, and incident lifecycle for the services you take on.
- Correctness is part of the culture. Tests should prove the behavior their names claim, including the exact failure behavior where it matters.
- Written first: design documents and RCAs keep a team split across India and the US aligned without turning the day into meetings.
- Frequent, reviewed deployments: changes are shipped behind appropriate safeguards rather than accumulated into heroic release cycles.
- Remote with bounded overlap: collaboration time is deliberate and limited; the rest of the work is designed to function asynchronously.
- We discuss our own platform gaps openly and expect engineers to notice, challenge, and improve them.

Perks & Advantages

- Competitive compensation + stock options.
- Remote-first role with flexibility to collaborate across locations.
- High ownership and autonomy - own backend services and technical decisions end to end.
- Direct access to engineering leadership and the people shaping Supero's product and architecture.
- Work on core platform infrastructure powering production applications.
- Modern backend and AI engineering - work across Python, distributed systems, multi-tenancy, transactional workflows, MCP, and AI-assisted development.
- Meaningful technical influence - contribute directly to architecture, engineering standards,



and platform direction.

About Supero Supero is an agent-native application development platform for building production-grade enterprise software from prompt to production. It generates typed relational data models, REST and CRUD APIs, SDKs, admin surfaces, React applications, transactional services, and workflows, and can be driven by external AI editors through MCP.

The platform is built around production invariants rather than prototype-only generation: hard multi-tenant isolation, role- and field-level access control, transactional state machines, idempotency, saga compensation, connectors, testing, and deployment. The engineering challenge is to make those guarantees hold underneath every application built on the platform.

Optional Build Challenge - Skip the Take-Home

Senior candidates may build a small system on Supero or submit something they have already built. Completing the build is optional, but it can replace the initial screening conversation and separate take-home exercise.

- If building on Supero, keep it small: approximately 3-5 entities, 2 roles, and at least one meaningful failure or edge case.
- Prefer the MCP route from an AI editor such as Claude Code, Cursor, or Copilot; this is closest to how the platform is intended to be used.
- Enable multi-tenancy and verify that the model survives a second tenant.
- Aim for about 90 minutes and do not exceed four hours.
- Submit a screenshot, live URL, optional source repository, a short explanation of what you modeled, one decision you reversed, and what you would improve about Supero.
- Alternatively, submit an existing project in any stack with a short explanation of its data model and a decision you would now change. Both routes are evaluated using the same engineering criteria.

What We Score We do not score visual polish. We look for defensible data modeling, tenant-safe behavior, correct permissions, explicit unhappy paths, sound engineering judgment, and the ability to notice and clearly explain weaknesses in the platform. For a senior backend candidate, we pay particular attention to how you reason about invariants, concurrency, retries, state transitions, idempotency, and partial failure.

Hiring Process

- Step 1 - Apply. A person reads the application. If you submit a build, that is reviewed first.
- Step 2 - 30-minute conversation with the person who would manage you, focused on systems you have built. This is skipped if you submitted a qualifying build.
- Step 3 - 90-minute technical session using a real engineering problem from the backlog or a walkthrough of your build. No algorithm puzzles or whiteboard trivia.
- Step 4 - Two 45-minute conversations with people you would work with, including a design-review simulation.
- Step 5 - Founder conversation, followed by the final decision and offer where applicable.

Candidate Resources

- Careers: https://www.supero.dev/careers/
- Platform: https://www.supero.dev/platform/
- MCP: https://www.supero.dev/mcp
- GitHub: https://github.com/supero-platform/supero-apps
- LinkedIn: https://www.linkedin.com/company/supero-dev/
- Documentation: https://docs.supero.dev/

Equal Opportunity Supero is an equal opportunity employer. We consider applicants based on qualifications, skills, and experience without regard to characteristics protected by applicable law.

📌 Senior Backend Engineer (Python) (Bengaluru)
🏢 Supero
📍 Bengaluru