About the Client
Our client is developing a distributed data streaming and processing platform that combines a control plane for orchestration, a data plane for runtime operations, distributed storage, and a custom DSL parser/compiler.
Project details
The system is built around Rust for safety and performance, with a strong focus on type-safe, async, cloud-native distributed systems. End Customers are internal users and enterprise clients adopting this platform for real-time data product management.

The project's core stack includes:
Rust, Tokio, RPC: tonic (gRPC with protobuf), PostgreSQL with Diesel ORM (asynchronous via diesel-async), Apache Kafka (rdkafka), AWS (S3, ECR, EKS, CodeArtifact), Kubernetes, Terraform, HashiCorp Vault, JWT authentication, mTLS

Your Team
You will be the first Rust developer in the team initially, with potential future expansion. And work closely with and report to the Managing Director/Core Platform Lead. Direct collaboration: Lead + internal engineering resources.
What's in it for you

• Interview process that respects people and their time
• Professional and open IT community
• Internal meet-ups and resources for knowledge sharing
• Time for recovery and relaxation
• Bright online and offline events
• Opportunity to become part of our internal volunteer community

Responsibilities
We are seeking an experienced Rust developer to support core platform development across our distributed systems architecture. This is a position requiring deep expertise in async Rust, distributed systems, and cloud-native technologies.

• You will support ongoing core development in Rust across the control plane, data plane, and storage service.
• Collaborate closely with the Core Platform Lead to establish core architecture patterns, CI/CD, and platform reliability.
• You will be working on the following Architecture Components:
• Control Plane – Kubernetes orchestration, AWS provisioning, Vault integration.
• Data Plane – Runtime execution, stream processing, and transformation nodes.
• Storage Service – Transactional distributed storage built on S3, PostgreSQL, Kafka.
• Parser – Rust-based DSL compiler (chumsky, salsa).
• CLI Tooling – Admin lifecycle management, authentication, and code generation.

Skills

Must have

• 5+ years of professional Rust development experience, extensive experience with Tokio runtime and ecosystem, experience with Futures, streams, and async traits.

Strong systems programming background:

• Сoncurrent and parallel programming
• Lock-free data structures (Arc, DashMap), memory management and performance optimization
• PostgreSQL database experience, ORM experience (Diesel preferred)

Distributed systems knowledge:

• Message queues (Kafka preferred)
• At-least-once and exactly-once semantics, distributed state management, partitioning and sharding strategies

gRPC and protocol buffers:

• Service definition and implementation, streaming RPC patterns

Testing discipline:

• Unit and integration testing, async test patterns, property-based testing, test containers

Desirable

• Kubernetes: Custom Resource Definitions (CRDs), operators and controllers, Kubernetes API client usage
• AWS: S3 (especially multipart uploads), EKS, ECR, IAM policies and roles
• Security: HashiCorp Vault, TLS/mTLS implementation, JWT authentication and authorization, PKI certificate management
• Parser/compiler experience: Parser combinator libraries, T-type systems and type inference, AST transformations
• Infrastructure as Code: Terraform (understanding deployments)
• Cargo ecosystem: Workspace management, proc macros and derive macros, feature flags and conditional compilation
• AI-assisted development: Experience with AI coding tools (Cursor IDE, GitHub Copilot, or similar)