Software Engineer - Backend

Lakefusion; Texas; On-site; USD 110,000 - 170,000; Full time

Job summary

LakeFusion seeks a Software Engineer - Backend to design and scale a real-time API for enterprise workloads, running across Azure, AWS, and customer-managed Kubernetes clusters. The role emphasizes defensive design, observability, and testing under failure conditions.

You will own the architecture of high-throughput APIs, integrate with MongoDB, Databricks Delta Lake, and Unity Catalog, and ensure smooth interoperability between FastAPI and .NET services in diverse environments.

Qualifications

• 2+ years backend engineering building production-grade services or microservices.
• 2+ years Python experience with FastAPI, ASGI server tuning, asyncio, and profiling.
• 2+ years of .NET Core / .NET 6+ (C#) with RESTful APIs and DI architectures.
• 2+ years of MongoDB experience including schema design and indexing.

Responsibilities

• Own architecture and implementation of a high-throughput real-time API on Kubernetes.
• Develop core enterprise backends using .NET and FastAPI for interoperability with NoSQL stores.
• Design for resilience, graceful degradation, and fault tolerance under failures or outages.
• Tune Kubernetes autoscaling (HPA, KEDA) for bursty production workloads.
• Optimize NoSQL data stores (MongoDB) for low-latency queries.
• Build streaming pipelines and data lakehouse integrations for real-time analytics.
• Ensure portability to customer environments with restricted networks and identities.

Skills

Python (FastAPI)

ASGI tuning

C# / .NET Core

MongoDB

Kubernetes (HPA/KEDA)

Observability (OpenTelemetry)

Distributed systems

RESTful APIs

Tools

Docker

Databricks Connect

Job description

LakeFusion is seeking a Software Engineer - Backend to build and scale our real-time API to enterprise production workloads. This is a deeply technical role focused on building resilient, fault-tolerant, high-throughput distributed systems that bridge enterprise backends with high-performance Python microservices and data lakehouse platforms.

A critical dimension of this role: we ship into customer environments. You won't just write code that works on our infrastructure — you'll build systems robust enough to run across Azure, AWS, and customer-managed Kubernetes clusters where you don't control the network, the identity provider, the observability stack, or the operator. That requires a particular kind of engineering discipline: defensive design, strong observability, minimal environmental assumptions, and thorough testing under failure conditions.

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.

What we're looking for

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

Nice-to-have

• Databricks experience: Familiarity with Databricks Connect, Delta Lake, Spark SQL, or MLflow integrations.
• Experience with event-driven architectures and streaming platforms (Kafka, RabbitMQ, or AWS EventBridge).
• Experience deploying into enterprise customer environments with strict security/compliance constraints (customer-managed identity, private networking, private endpoints).
• Experience with dual-paradigm data access patterns bridging SQL and NoSQL/Document databases.

About LakeFusion

LakeFusion is the modern Master Data Management (MDM) company. Global enterprises across industries ranging from retail to manufacturing and financial services rely on the LakeFusion platform to unify, govern, and deliver trusted data entities such as customers, products, suppliers, and employees. Built natively on the Databricks Lakehouse, LakeFusion creates a single source of truth that powers analytics and AI. LakeFusion enables organizations worldwide to accelerate innovation with trusted and governed data.