I build software where correctness, performance, and clear system boundaries matter. Rust-first, currently pushing deeper into accounting systems, finance infrastructure, and distributed systems.
fn main() {
let fearless = true;
let dapper = Engineer {
language: Rust,
building: [Ledgers, SettlementRails, DistributedSystems],
invariant: "invalid states should not compile",
};
loop {
dapper.ship(one_problem_at_a_time());
}
}Financial and accounting systems where data integrity isn't optional:
- Ledgers — double-entry models with invariants the compiler enforces
- Reconciliation — turning messy business logic into precise software models
- Audit trails — event sourcing and append-only histories that tell the truth
- Settlement — payment infrastructure that fails predictably and recovers cleanly
- Distribution — consensus, replication, queues, and fault-tolerant services in Rust
Primary language Rust
Systems interest distributed systems, backend infrastructure
Domain interest accounting, finance, data integrity
Operating mode learn deeply, build carefully, ship deliberatelyGood software should make invalid states difficult to represent.
That's the part of Rust I like most — it rewards precision. The same idea applies to accounting and finance. If the model is vague, the bugs get expensive. I want systems where the rules are explicit, the data tells the truth, and the architecture survives real-world failure.
many problems,
solved in Rust.