roigdev

Software engineering consultancy

Distributed systems that hold up under pressure.

We design, build and harden backend systems where correctness is not optional: event-driven platforms, high-throughput services, and infrastructure that has to keep working when parts of it don't. Rust is our main language, because it turns whole classes of failure into compile errors.

Start a conversationExplore services
  • Rust
  • Distributed systems
  • Event-driven
  • Resilience
  • Security
root verified · every leaf accounted for

Services

Engineering for systems that can't afford to guess

Five areas of focus that overlap in practice: a platform that moves events between services has to be fast, has to survive partial failure, and has to be secure.

01

Distributed systems

Replication, consensus, partitioning and consistency models, designed explicitly rather than discovered in production.

Learn more 02

Event-driven architecture

Event sourcing, streaming pipelines and message-driven services with clear delivery, ordering and replay semantics.

Learn more 03

High-performance systems

Profiling-driven optimisation of latency and throughput, focused on tail latency and predictable resource use.

Learn more 04

Resilience & error handling

Typed, explicit error handling and resilience patterns such as timeouts, retries, circuit breakers and load shedding, tested under real faults.

Learn more 05

Security engineering

Memory-safe implementation, threat modelling, secure design review and software supply-chain hardening.

Learn more rs

Rust, by default

Memory safety, fearless concurrency and errors in the type system. Why Rust is at the centre of how we build.

Our approach

Principles

How we build

  1. Failure is a design input

    Networks partition, disks fill, dependencies time out. We decide up front how every component behaves when that happens, and we test it.

  2. Make invalid states unrepresentable

    Invariants live in the type system, so whole categories of bugs fail to compile instead of waiting to be found in production.

  3. Measure, don't guess

    Performance work starts from profiles, flame graphs and tail-latency percentiles. Every optimisation is benchmarked before and after.

  4. Secure by construction

    Memory safety, least privilege, audited dependencies and threat models are part of the architecture, not a checklist at the end.

Errors are values, not surprises

In Rust, a function that can fail says so in its signature, and the compiler won’t let the caller ignore it. We build on that: every failure mode gets a name, a type and an explicit decision about what happens next.

Nothing is retried blindly, nothing is silently dropped, and the next engineer can see every path the code can take, just by reading it.

match ledger.append(&event).await {
    Ok(offset) => consumer.commit(offset).await?,
    Err(AppendError::Timeout) => retries.schedule(event, backoff.next()),
    Err(AppendError::Conflict { expected, found }) => {
        reconcile(&event, expected, found).await?
    }
    Err(err) => dead_letters.publish(event, err).await?,
}

That’s the standard we hold all of our work to.

Have a system that needs to be faster, safer or harder to break?

Tell us what you're building or what's hurting. We'll give you an honest view of whether, and how, we can help.

Start a conversation