Python Developer Lead

Dailyhunt; Bengaluru; On-site; INR 4,200,000 - 7,500,000; Full time

Job summary

Dailyhunt is seeking a Python Developer to design and operate customer-facing services that run at high request rates with strict latency requirements in Bengaluru, India. You will implement ML/LLM-backed features and ensure reliable, scalable production systems.

The role requires 5+ years of building production Python systems, expertise with web frameworks, and experience with high-throughput architectures. You will mentor, optimize performance, and participate in on-call responsibilities.

Qualifications

• 5+ years building production Python services.
• Proficient with FastAPI, Django, or Flask and their request lifecycle.
• Experience with high-throughput, low-latency systems and concrete RPS talks.
• Async programming with asyncio, threading, or multiprocessing.
• Strong SQL skills and read/write scaling patterns.
• Caching and messaging at scale (Redis, Kafka, RabbitMQ).
• Applied AI/ML in production: LLM APIs, embeddings, or RAG pipelines.
• Testing discipline: pytest, CI, and load testing.

Responsibilities

• Design, build, and operate Python services handling high requests-per-second with strict latency SLAs.
• Own performance end-to-end: profiling, caching, connection pooling, and load testing.
• Build ML/LLM-backed features in production: inference endpoints and monitoring.
• Balance model quality, latency, and cost via batching, quantization, and caching.
• Design for failure: retries, timeouts, circuit breakers, graceful degradation.
• Instrument services: latency percentiles, error budgets, and model quality metrics.
• Participate in on-call and drive incident fixes.
• Review code and mentor mid-level engineers on Python best practices.

Skills

5+ years production Python

Web frameworks (FastAPI/Django/Flask)

Async programming

Strong SQL (PostgreSQL/MySQL)

Caching & messaging (Redis, Kafka)

Applied AI/ML in production

Testing (pytest, CI, load testing)

Docker, Git, CI/CD

Tools

Redis

Kafka/RabbitMQ/PubSub

Git

Docker

Kubernetes (prod)

PyTorch / TensorFlow / scikit-learn

Job description

Python Developer High-Scale Backend & Applied AI/ML

Location: Bengaluru, India

Experience: 5+ years

Team: Core Product Engineering

About the Role

This role sits on our customer-facing product — services that handle sustained high request volumes with hard latency commitments, where a p95 regression is a visible incident, not a chart. We are also embedding ML and LLM-driven capabilities directly into those request paths, which means inference has to hold the same latency and reliability bar as everything else.

We are looking for an engineer who is fluent in both halves of that: writing Python that survives real traffic, and putting models into production without turning them into the slowest hop in the chain.

What You Will Do

• Design, build, and operate customer-facing Python services running at high requests-per-second with strict latency SLAs.
• Own performance end to end — profiling, caching strategy, connection pooling, query tuning, and load testing against realistic traffic models.
• Build and maintain ML/LLM-backed features in production: inference endpoints, feature pipelines, prompt and retrieval flows, evaluation, and monitoring for drift and regression.
• Make deliberate trade-offs between model quality, latency, and cost — including batching, quantization, caching, and fallback paths.
• Design for failure — retries, idempotency, timeouts, circuit breakers, graceful degradation under load.
• Instrument services properly: latency percentiles, error budgets, saturation signals, and model-quality metrics.
• Participate in on-call for the services you own, and drive the fixes that come out of it.
• Review code and mentor mid-level engineers on Python idioms, testing discipline, and production thinking.

Must-Have Skills

• 5+ years building production Python systems — services under real traffic, not scripting or notebooks alone.
• Deep familiarity with at least one web framework (FastAPI, Django, or Flask) and its request lifecycle.
• Demonstrated experience with high-throughput, low-latency systems — you can talk concretely about the RPS you handled, where it broke, and what you did about it.
• Async programming and concurrency in Python (asyncio, threading, multiprocessing) — and the judgement to know which applies.
• Strong SQL skills with PostgreSQL or MySQL, including indexing, query tuning, and read/write scaling patterns.
• Caching and messaging at scale — Redis, plus Kafka, RabbitMQ, or Pub/Sub.
• Applied AI/ML experience — serving models in production, working with LLM APIs, or building RAG/embedding pipelines. Comfort with PyTorch, TensorFlow, scikit-learn, or Hugging Face as appropriate to the problem.
• Testing discipline: pytest, mocking, fixtures, CI-integrated suites, and load testing (JMeter, k6, Gatling, or Locust).
• Docker, Git, and CI/CD pipeline experience.

Good to Have

• Kubernetes in production — HPA, resource tuning, debugging your own pods.
• Model serving infrastructure — Triton, TorchServe, vLLM, KServe.
• Vector databases and retrieval systems (pgvector, Pinecone, Milvus, Weaviate).
• MLOps tooling — MLflow, Kubeflow, feature stores, experiment tracking.
• GCP or Azure at SDK level, including their managed ML services.
• Experience with gRPC, or with API gateway and rate-limiting design.