Senior Rust Engineer

We're Hiring: Senior Rust Engineer

Location: United Arab Emirates (Remote)

Employment Type: Full-Time

Experience Level: Senior

Work Arrangement: Fully Remote

About Us

We are a globally focused organization committed to building secure, scalable, resilient, and high-performance software products and digital platforms across diverse markets.

Our engineering teams collaborate across Software Engineering, Product, Platform, Cloud, Infrastructure, Security, Data, DevOps, and Operations to develop reliable systems that support critical business processes and evolving customer requirements.

The Role

We are seeking an experienced Senior Rust Engineer to design, develop, optimize, test, and maintain high-performance software systems using Rust.

The ideal candidate will combine strong Rust expertise with deep knowledge of systems programming, concurrency, distributed systems, networking, performance engineering, APIs, cloud infrastructure, and secure software development. The role will contribute to technically demanding applications and platforms where reliability, memory safety, efficiency, and predictable performance are critical.

Key Responsibilities

• Design, develop, test, deploy, and maintain production-grade software using Rust.
• Build secure, reliable, maintainable, and high-performance systems.
• Translate complex business and technical requirements into robust software solutions.
• Participate in software architecture, system design, and technical decision-making.
• Develop performance-sensitive applications and services using Rust.
• Apply Rust ownership, borrowing, lifetimes, traits, generics, and type-system capabilities effectively.
• Design software using idiomatic Rust and established engineering best practices.
• Develop concurrent and parallel applications using appropriate Rust concurrency models.
• Implement asynchronous applications using async Rust, futures, tasks, and appropriate runtimes.
• Design and develop scalable backend services, APIs, and distributed components.
• Build RESTful APIs, gRPC services, and other service interfaces where appropriate.
• Develop event-driven services and asynchronous processing systems.
• Integrate applications with message brokers, queues, streaming platforms, and external services.
• Develop systems that interact with databases, caches, storage platforms, and distributed data systems.
• Design efficient data structures, algorithms, and processing pipelines.
• Optimize CPU utilization, memory consumption, latency, throughput, and I/O performance.
• Conduct profiling, benchmarking, load testing, and performance analysis.
• Identify bottlenecks and implement targeted performance improvements.
• Develop efficient memory-management and resource-management strategies.
• Ensure applications handle errors, failures, timeouts, retries, and resource exhaustion appropriately.
• Design systems with fault tolerance, graceful degradation, and recovery mechanisms.
• Develop secure authentication and authorization mechanisms.
• Implement appropriate encryption, secrets management, input validation, and access controls.
• Apply secure coding principles and protect applications against common security vulnerabilities.
• Collaborate with cybersecurity teams to identify and remediate software-security risks.
• Develop unit, integration, functional, system, and end-to-end tests.
• Establish effective testing strategies for complex and performance-sensitive systems.
• Improve automated test coverage and software quality.
• Conduct code reviews and provide detailed technical feedback.
• Maintain high standards for code quality, readability, maintainability, and reliability.
• Investigate production incidents, software defects, crashes, memory issues, and performance problems.
• Perform root-cause analysis and implement permanent corrective actions.
• Analyze logs, traces, metrics, stack traces, core dumps, and diagnostic information.
• Develop observability capabilities covering metrics, structured logging, tracing, health checks, and system diagnostics.
• Work with DevOps and platform teams to improve deployment and operational reliability.
• Develop and maintain CI/CD pipelines for Rust applications.
• Build and maintain containerized Rust applications using Docker and Kubernetes where appropriate.
• Develop software for cloud and distributed infrastructure environments.
• Integrate Rust applications with cloud services, storage systems, networking services, and managed platforms.
• Support infrastructure-as-code and automated deployment practices where relevant.
• Design applications for high availability, resilience, disaster recovery, and business continuity.
• Participate in capacity planning, load testing, stress testing, and scalability assessments.
• Design software capable of operating efficiently under high workloads and constrained resources.
• Develop reusable Rust crates, libraries, SDKs, frameworks, and internal engineering components.
• Establish reusable coding patterns and technical standards for Rust development.
• Evaluate third-party Rust crates for security, stability, maintainability, licensing, and performance.
• Manage dependencies and address dependency vulnerabilities and compatibility issues.
• Maintain Cargo configurations, workspace structures, build processes, and dependency management.
• Configure and maintain appropriate Rust compiler, toolchain, linting, formatting, and build standards.
• Use tools such as Cargo, rustfmt, Clippy, testing frameworks, profilers, and debugging utilities effectively.
• Design and implement integrations with internal platforms and external systems.
• Maintain clear API contracts, schemas, interfaces, and compatibility requirements.
• Participate in migration of legacy components to Rust where technical and business value justify modernization.
• Assess existing systems and identify opportunities for performance, reliability, security, or maintainability improvements.
• Collaborate with Product Managers, Architects, QA Engineers, DevOps Engineers, Security Engineers, Data Engineers, and other stakeholders.
• Participate in Agile planning, technical refinement, estimation, reviews, and retrospectives.
• Break complex technical requirements into manageable engineering tasks.
• Estimate technical effort, identify dependencies, and communicate delivery risks.
• Lead technical discovery, prototypes, proofs of concept, and architectural experiments.
• Evaluate emerging Rust libraries, frameworks, runtimes, tooling, and systems-programming techniques.
• Stay current with developments in Rust, systems programming, distributed systems, cloud computing, and software security.
• Develop and maintain architecture documentation, technical specifications, API documentation, and operational runbooks.
• Provide technical guidance and mentoring to junior and mid-level engineers.
• Support engineers in debugging complex systems and performance issues.
• Lead technical initiatives and contribute to engineering roadmaps.
• Promote engineering practices focused on memory safety, security, reliability, performance, automation, and maintainability.
• Identify opportunities to improve development productivity, system performance, operational efficiency, and software quality.

Key Performance Indicators

• Rust development delivery performance
• Production software quality
• Production defect rate
• Code-review compliance
• Automated test coverage
• Unit-test coverage
• Integration-test coverage
• Application availability
• System uptime
• Service reliability
• Application latency
• Processing throughput
• CPU utilization efficiency
• Memory utilization efficiency
• Memory safety defect rate
• Resource utilization efficiency
• Crash and panic frequency
• Error rate
• Mean time to detection
• Mean time to resolution
• Production incident frequency
• Repeat incident rate
• Root-cause resolution effectiveness
• Performance improvement delivery
• Benchmark performance
• Load-test results
• Scalability performance
• Concurrent-processing efficiency
• Database performance
• API response-time performance
• Message-processing reliability
• CI/CD pipeline success rate
• Deployment success rate
• Release reliability
• Rollback frequency
• Security vulnerability remediation
• Dependency vulnerability resolution
• Secure-development compliance
• Technical-debt reduction
• Legacy-component modernization
• Observability coverage
• Monitoring effectiveness
• Documentation completeness
• Reusable-component adoption
• Engineering productivity
• Stakeholder satisfaction
• Mentoring effectiveness
• Continuous-improvement delivery

Ideal Candidate

The successful candidate should have strong experience in Rust software development, systems programming, backend engineering, distributed systems, performance engineering, networking, cloud-native applications, or other high-performance software environments, preferably within technology, financial services, cybersecurity, telecommunications, infrastructure, SaaS, or other technically demanding organizations.

The candidate should demonstrate:

• Strong professional experience developing production software using Rust.
• Deep understanding of Rust ownership, borrowing, lifetimes, traits, generics, enums, pattern matching, and type-system principles.
• Strong knowledge of idiomatic Rust and modern Rust development practices.
• Proven experience building reliable and performance-sensitive software.
• Strong understanding of concurrency, parallelism, asynchronous programming, and synchronization.
• Experience with async Rust and commonly used asynchronous runtimes.
• Strong knowledge of data structures, algorithms, memory management, and resource efficiency.
• Experience designing scalable backend services and distributed systems.
• Strong understanding of REST APIs, gRPC, networking, and service-oriented architectures.
• Experience with databases, caching systems, message brokers, and distributed storage technologies.
• Strong performance-analysis and optimization capabilities.
• Experience with profiling, benchmarking, load testing, and performance tuning.
• Strong understanding of fault tolerance, resilience, availability, and distributed-system principles.