Looking for an audit first? Start here →
Senior Rust Developer

Architecture & Implementation.
After the Audit.

Specialized Rust development for projects that cannot afford failure. I don't take on basic work. Only high-complexity challenges.

27K Queries/sec
<1ms P99 Latency
766B Per Document
impl Excellence for YourProject {
    fn deliver(&self) -> Result<Success, Never> {
        // Zero-cost abstractions
        // Memory safety guaranteed
        // Fearless concurrency
        Ok!(Success::Delivered)
    }
}

What I DON'T Do

✕

Simple scripts or basic automations

✕

CRUD applications with no real complexity

✕

Projects without clear performance requirements

✕

Hourly work with no commitment to results

High-Level Specialties

I only take on projects that require real expertise in low-level systems

Distributed Systems

Architectures that scale horizontally with eventual or strong consistency as needed.

  • Event sourcing & message queues
  • Async coordination patterns
  • Horizontal scaling design

Compilers & Interpreters

DSLs, domain-specific languages, transpilers, and code optimizers.

  • Efficient Lexers/Parsers
  • AST optimization
  • Code generation

Custom Databases

Storage engines, key-value stores, time-series databases optimized for specific use cases.

  • B-Tree / LSM-Tree
  • Write-ahead logging
  • Memory-mapped I/O

Critical Systems

Software for fintech, healthcare, infrastructure where failure is not an option.

  • Comprehensive test coverage
  • Fault tolerance
  • Real-time constraints

Performance Engineering

Extreme optimization of existing systems. Profiling, SIMD, cache optimization.

  • Zero-copy architectures
  • Lock-free data structures
  • CPU cache optimization

Search Engine From Scratch

Everything needed to build a production-grade search engine

Query Layer
Query Parser
Query Optimizer
Result Ranker
↓
Index Layer
Inverted Index
Forward Index
Posting Lists
↓
Storage Layer
Segment Files
Commit Log
Memory Buffer

Essential Components

01

Tokenizer & Analyzer

Text processing pipeline: normalization, stemming, stop words, n-grams.

tantivy::tokenizer
02

Inverted Index

Core data structure. Maps terms to documents with positions and frequencies.

HashMap<Term, PostingList>
03

Scoring & Ranking

BM25, TF-IDF, vector similarity. Combining signals for optimal relevance.

BM25 { k1: 1.2, b: 0.75 }
04

Query DSL

Query parser: booleans, phrases, wildcards, fuzzy matching, range queries.

QueryParser::parse()
05

Segment Management

Merging, compaction, garbage collection. Keeps the index optimized.

IndexWriter::merge()
06

API Layer

Async REST API with Axum, rate limiting, health checks and metrics.

axum::Router::new()

Recommended Tech Stack

Tantivy Full-text search library
Tokio Async runtime
Serde Serialization
Tonic gRPC framework
RocksDB Embedded storage
Rayon Parallel processing

Measured Metrics

<1ms P99 Latency (50K docs)
27K Queries/sec (100 workers)
766B Memory per document
21K Docs/sec indexing

Battle-Tested Stack

Core

Rust async/await unsafe no_std

Networking

Tokio Hyper Tonic (gRPC) Quinn (QUIC)

Data

Sled RocksDB SQLx Arrow

Performance

SIMD Rayon crossbeam parking_lot

Work Process

1

Discovery Call

Technical evaluation of the project. If it's not complex enough, I decline.

2

Technical Spec

Detailed architecture document, trade-offs, and success metrics.

3

Implementation

Iterative development with benchmarks and tests. Weekly code reviews.

4

Delivery

Documentation, knowledge transfer, and post-delivery support.

Got a Real Challenge?

I only respond to projects that require genuine expertise in low-level systems. If your project isn't complex enough, I'm not the right fit.

Minimum Requirements:

  • Budget matching the complexity
  • Defined performance requirements
  • Realistic timeline (>3 months)
  • Technical team to collaborate with