// Senior Engineer · roex.pro

Systems that
don't break.

20+ years building high-load distributed systems — from financial trading infrastructure to HIPAA-grade microservices. Now fully focused on Rust and fintech.

Write me github/rutmir

20⁺

Years in production

9⁺

Years high-load systems

Fintech

Current focus · Rust

// expertise

Where deep knowledge meets
hard constraints.

📊

Financial Domain

Formal background in financial management & analysis, FSFR series 1.0 certifications. Understands markets and transaction systems at the model level — not just the API.

FSFR 1.0 Fintech Transactions

⚡

High-Load Systems

9+ years designing microservice architectures for US-based projects. Fault-tolerant PostgreSQL/Patroni clusters, HIPAA compliance, zero-downtime deployments.

PostgreSQL Patroni HIPAA Microservices

🦀

Rust & Go

Transitioned from Go to Rust for memory-safety guarantees and elimination of race conditions — qualities that are non-negotiable in financial services.

Rust Go Memory Safety

// why rust

A deliberate
choice.

Go was — and remains — an excellent language. But for fintech, the margin for error is zero. Rust's ownership model makes entire classes of bugs impossible at compile time.

No garbage-collector pauses. No data races. No undefined behavior hiding in production. Just predictable, auditable, fast code — exactly what financial infrastructure demands.

// memory safety at compile time
fn process_transaction<T>(
    ledger: &mut Ledger,
    tx: Transaction<T>,
) -> Result<Receipt, LedgerError> {
    ledger.validate(&tx)?;
    let receipt = ledger.apply(tx)?;
    // borrow checker guarantees
    // no double-spend possible
    Ok(receipt)
}

// zero-cost abstractions
fn settlement_pipeline(
    stream: impl Stream<Transaction>,
) -> impl Future<Output = Report> {
    stream
        .filter(|tx| tx.is_valid())
        .map(apply_rules)
        .collect()
}

// contact

Let's build
something solid.

Open to Rust / fintech projects, system design consulting, and technical partnerships.

github/rutmir

Systems that don't break.

Where deep knowledge meetshard constraints.