Rust Backend Developer - BR

About Fluxicart

Fluxicart is a white-label multi-tenant marketplace platform that empowers merchants to create their own fully customized online stores (themes, domains, branding) while operating under a centralized platform that manages payments, deliveries, commissions, and administrative dashboards.

We are building the "Shopify + iFood + Production System" for the European market, starting with Ireland and expanding to Brazil.

Our stack is modern and ambitious:

• Current: Next.js 15 (App Router) + React 19 + TypeScript + Prisma + SQLite/PostgreSQL
• Future: Migrating to microservices with Rust (Axum) + gRPC + NATS + Redis

We are backed by a clear product vision, an active user base, and a roadmap that includes international expansion, WebSocket real-time features, and high-performance Rust microservices.

The Role

We are looking for a Senior Rust Backend Developer to lead the migration of our monolith Next.js platform to a high-performance microservices architecture in Rust.

In this role, you will:

• Design and build scalable, low-latency microservices using Rust and Axum
• Own the migration strategy from Node.js to Rust using the Strangler Fig pattern
• Build services for: Auth, Catalog, Orders, Payments, Logistics, and Analytics
• Implement gRPC for service-to-service communication and NATS for event-driven architecture
• Design database schemas with SQLx (type-safe SQL) and optimize PostgreSQL queries
• Build caching layers with Redis (write-through, TTL, invalidation)
• Implement distributed tracing with OpenTelemetry + Tempo
• Monitor services with Prometheus + Grafana + Loki
• Deploy to Kubernetes (EKS) with CI/CD (GitHub Actions)
• Mentor junior developers and participate in code reviews, RFCs, and architectural decisions
• Contribute to performance tuning — we target p95 latency <100ms

You'll have a direct impact on the product and the company's growth — we're a flat team where engineers ship fast, learn continuously, and shape the product roadmap.

Key Responsibilities

Microservices Development (70%)

• Build RESTful APIs with Axum (Web framework) and Serde (serialization)
• Implement gRPC services with tonic and prost (Protocol Buffers)
• Write type-safe SQL queries with SQLx (compile-time checked)
• Design PostgreSQL schemas with proper indexing, foreign keys, and Row-Level Security
• Implement Redis caching strategies (TTL, invalidation, cache-aside, write-through)
• Build event-driven systems with NATS (JetStream for persistence)
• Write idiomatic, performant Rust with proper error handling (anyhow, thiserror)
• Implement health checks, graceful shutdown, and readiness probes for Kubernetes

Architecture & Strategy (20%)

• Lead the Strangler Fig migration from Next.js monolith to Rust microservices
• Design API versioning strategies (v1 → v2 with deprecation policies)
• Implement Saga Pattern for distributed transactions (Orders ↔ Payments ↔ Logistics)
• Design multi-tenant data isolation with PostgreSQL RLS and shopId partitioning
• Plan sharding strategies for >10,000 stores
• Optimize for low latency and high throughput (target: 20,000+ req/s per service)

Observability & DevOps (10%)

• Implement structured logging with tracing (JSON format)
• Add distributed tracing with OpenTelemetry (correlate logs ↔ traces ↔ metrics)
• Create Prometheus metrics (RED method: Rate, Errors, Duration)
• Build Grafana dashboards for service health and business metrics
• Set up alerts (Grafana AlertManager + PagerDuty/Slack)
• Deploy with Docker and Kubernetes (EKS)
• Implement Blue/Green deployments and canary releases

Requirements

Must-Have

Requirement Details:

Experience: 5+ years of backend development, 3+ years with Rust.

Rust: Expert-level Rust — ownership, borrowing, lifetimes, traits, error handling.

Web Frameworks: Axum or Actix-web.

Async Rust: Tokio, async/await, spawning tasks, channels.

Database: SQLx (type-safe SQL) — compile-time checked queries.

SQL: Expert-level PostgreSQL — query optimization, indexing, transactions, RLS.

gRPC: Experience with tonic + prost (Protocol Buffers).

Message Queues: NATS, Kafka, RabbitMQ, or similar.

Caching: Redis — caching strategies, TTL, invalidation.

Testing: Unit tests, integration tests with sqlx::test, mocks (mockall).

Observability: OpenTelemetry, tracing, Prometheus, Grafana.

Version Control: Git, GitHub, PR workflows, CI/CD.

Nice-to-Have

Requirement Details:

Kubernetes: Experience with EKS, Helm, Kustomize.

AWS/GCP: RDS, S3, EKS, CloudWatch.

Distributed Systems: Saga Pattern, CQRS, Event Sourcing.

Payment Gateways: Stripe, Adyen, or similar.

Search Engines: Meilisearch, Elasticsearch.

OLAP: ClickHouse, TimescaleDB.

Next.js: Understanding of the monolith we're migrating from.

E-commerce: Prior experience in e-commerce, marketplaces, or delivery platforms.