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