Summary
What you’ll impact
The Associate Backend Engineer is responsible for designing, building, and scaling a real‑time API that bridges enterprise backends with high‑performance Python microservices and data‑lakehouse platforms. The role uses Python/FastAPI, .NET/C#, MongoDB, and Kubernetes on Azure and AWS, with containerization, HPA/KEDA autoscaling, and OpenTelemetry for observability. Key duties include building resilient, fault‑tolerant architectures, optimizing low‑latency data access, tuning autoscaling, and profiling performance end‑to‑end. The engineer works with distributed teams to integrate Databricks Delta Lake, ensure portability in customer‑managed environments, and maintain logging, metrics, and tracing.
Responsibilities
What you'll do
- Scale the real-time API: Own the architecture and implementation of our high-throughput, low-latency API built in Python/FastAPI and deployed on Kubernetes.
- Maintain enterprise core: Develop and maintain core enterprise backends using .NET / C#, ensuring seamless interoperability between .NET services, FastAPI microservices, and NoSQL datastores.
- Build for resilience and fault tolerance: Design for graceful degradation under upstream failures, rate limits, partial outages, and retry storms. Eliminate silent failure modes.
- Engineer for autoscaling: Tune Kubernetes autoscaling behavior (HPA, KEDA, cluster autoscaler) to handle bursty production workloads across diverse customer environments.
- Optimize NoSQL data stores: Architect and optimize MongoDB collections, aggregation pipelines, indexing strategies, and asynchronous database connections for low-latency queries.
- Build streaming integrations: Develop streaming pipelines and background execution workflows that sync data between service, transactional, and analytical layers.
- Integrate Lakehouse analytics: Connect backend APIs with Databricks compute, Delta Lake tables, and Unity Catalog to expose real-time analytics and data pipelines to downstream consumers.
- Design for portability: Architect services that ship into customer environments and work reliably without serverless dependencies, with customer-controlled identity, restricted network egress, and varied observability stacks.
- Own performance: Profile, benchmark, and optimize for latency and throughput. Understand and tune the full stack — from FastAPI event loops and .NET memory management through connection pooling, caching, and downstream service calls.
Requirements
What you’ll bring
- 2 years of backend engineering experience building production-grade services and microservices.
- 2 years of deep Python expertise, with hands-on mastery of FastAPI, ASGI server tuning (uvloop/Uvicorn), async event loops (asyncio), Pydantic, and performance profiling.
- 2 years of hands-on experience in .NET Core / .NET 6+ (C#), building RESTful APIs, Dependency Injection architectures, Entity Framework Core, and enterprise backend components.
- 2 years of experience working with MongoDB, including schema design, aggregation pipelines, index tuning, and asynchronous drivers (Motor, PyMongo).
- Strong Kubernetes experience, particularly around autoscaling (HPA, KEDA), resource allocation, containerization (Docker), and production deployment patterns.
- Resilience and fault-tolerance engineering: circuit breakers, retries with backoff and jitter, bulkheads, timeouts, idempotency, and graceful degradation patterns.
- Deployment portability experience: you understand how to write software that runs in environments you don't control and can adapt to restricted network egress and custom identity providers.
- Strong observability instincts: structured logging, metrics, tracing (OpenTelemetry), and the discipline to make systems debuggable from the outside.
- Excellent technical communication, with experience collaborating across distributed engineering teams.