Senior Python Backend Software Engineer

At Kallikor, we're shaping the next generation of supply chain decision intelligence through simulation digital twins. We build living digital representations of real-world operations (warehouses, distribution networks, global logistics) that help organisations plan, optimise, and adapt as the world changes around them.

The Platform Team is the backbone that makes all of this work. We build the APIs and services every other team relies on, from the digital twin engine to the enterprise insights product. When we get it right, the rest of the company can move fast without tripping over the plumbing.

This is a backend engineering role. You'll design and ship robust Python services that handle real production traffic. You'll own the APIs other teams build on, the data models underneath them, and the reliability that keeps everything standing up. We need someone who writes clean, tested code, debugs tricky problems calmly, and cares about the people who use their services.

You'll work across our platform stack: FastAPI services, Postgres data models, background jobs, and the integrations that tie our teams together. You'll help set the technical direction and raise the bar for everyone around you.

Learn more at kallikor.ai.

Your Opportunity

• Own the platform APIs: Design and build the FastAPI services the rest of the company depends on. Clean contracts, sensible versioning, clear errors, so other teams can build on you with confidence.

• Design the data underneath: Model our Postgres schemas, keep queries fast as we grow, and make sensible calls about indexing, migrations, and when to reach for something else.

• Keep things fast and reliable: Add proper monitoring, logging, and alerting. Design for failure. Make sure a slow service degrades gracefully instead of falling over.

• Handle the heavy lifting off the request path: Move slow work into background jobs so the API stays snappy. Get retries, failures, and back-pressure right.

• Connect the teams: The Platform Team sits in the middle. You'll shape how our services talk to the Modelling, Product, and DevOps requirements, and smooth out the dependencies between them.

• Raise the bar: Mentor through code review and pairing. Teach good testing and production habits. Leave the codebase better than you found it.

Why you're made for this

• You're a strong production Python engineer: You write clean, maintainable, tested code. You understand async/await, know your way around a profiler, and can find the slow query or the memory leak. Your code passes review without drama.

• You've built real APIs: You've designed and run FastAPI services (or similar) that handle production traffic. You think about contracts, backwards compatibility, and the developers on the other end of your endpoints.

• You know your way around a database: You're comfortable with Postgres, from schema design to reading a query plan. You know when a database is the right tool and when it isn't.

• You think like a systems engineer: You design for failure, add instrumentation, and consider edge cases. You know "it works on my laptop" isn't shipping. You care about monitoring, logging, and graceful degradation.

• You ship in iterations: You deliver value in small steps and learn from what production tells you. Foundations matter to you, but you know the bigger risk is building the wrong thing, not building it slightly imperfectly. You ship, you learn, you improve.

• You thrive in a startup: You're comfortable with ambiguity and frequent change. You see shifting priorities as a chance to learn, not a problem. You reach out for input early and help others do the same.

What we're looking for specifically

Must have:

• 5+ years building production Python systems (backend services, APIs, data processing)

• Strong API design experience, ideally with FastAPI

• Solid Postgres experience: schema design, query tuning, migrations

• Strong software engineering fundamentals: testing, debugging, profiling

• Docker, CI/CD, and production deployment experience

Nice to have:

• AWS (or another major cloud)

• Kubernetes

• Celery or similar background job systems

• ClickHouse or another analytics database

• TypeScript, not needed for the role, but handy for working with the other teams

What you'll work with

• Backend Stack: Python, FastAPI, Postgres, Docker

• Also in the mix: Celery, ClickHouse, and TypeScript on the teams we integrate with

• Infrastructure: AWS, Docker, Kubernetes

• Team: A close-knit group of software engineers, working alongside Product, Modelling, and DevOps

Example projects you'll own

• Design a new FastAPI service other teams build on, from the API contract to the Postgres schema underneath

• Move a slow, blocking operation into a background job so the API stays fast under load

• Add monitoring and alerting that catches problems before users notice them

• Tune a Postgres query (or a ClickHouse one) that's become a bottleneck as data has grown

• Shape how the Platform Team's services talk to the rest of the company

About Us

Kallikor is determined to foster an environment where people can do their best work and feel like they belong. We believe a healthy culture, strong values and contribution from a diverse range of individuals will help us to achieve success.

We do not discriminate based on race, ethnicity, gender, ancestry, national origin, religion, sex, sexual orientation, gender identity, age, disability, veteran status, genetic information, marital status or any other legally protected status.