Skip to content

PROTOWORKS

Get notified

v0 · pre-seed · studio open to select engagements

Infrastructure as craft.

Protoworks is a one-person engineering studio. The work is backend systems, devops tooling, build systems, and the architectural scaffolding other engineering teams stand on.

Three ventures in build, no outside capital yet. The studio takes a small number of engagements alongside them.

See what we are buildingRead the brief

  • 12 yr

    shipped systems

  • 3 ventures

    in build

  • Typed core

    ports & adapters

  • Pre-seed

    stage

In build

What the studio is building.

No client roster to show yet — the studio is pre-seed and has not closed a named engagement. These are the three ventures it is building in the meantime. All three are live enough to visit.

Capability

What the studio builds.

Four registers of work, each on a single seam. Engagements usually sit on one or two at a time, not all four.

  • Backend systems

    Event-sourced services with clean cores. Pure logic at the centre, adapters at the edges, illegal states designed out.

    services · apis · data

  • Devops & landing zones

    Reproducible cloud foundations. Environment isolation, composable modules, changes applied in dependency order.

    terraform · cloud · iac

  • Build & monorepo tooling

    Task graphs that survive large multi-language monorepos without ceremony. Remote cache, hermetic builds, the smallest useful seam.

    moonrepo · remote cache

  • Developer tooling

    Internal CLIs, platform surfaces, and the tooling that pays back its build cost in the first quarter.

    clis · platforms

Fragment

A small piece of the work.

A pure decider for an event-sourced core: state plus command returns events — no clock, no IO. The adapters run the loop at the seams.

core/src/decision.rs

rust · 22 lines

// Pure decider: (state, command) -> events.
// No IO. No clock. Adapters run the loop at the seams.

pub enum Command {
    Open(AccountId),
    Post(Posting),
    Reverse(EntryId, Reason),
}

pub enum Decision {
    Accepted(Vec<Event>),
    Rejected { because: RejectReason },
}

pub fn decide(state: &Ledger, cmd: Command) -> Decision {
    use Command::*;
    match (state.is_open(), cmd) {
        (false, Post(_))       => Decision::Rejected { because: RejectReason::Closed },
        (true,  Post(p))       => Decision::Accepted(vec![Event::Posted(p)]),
        (_,     Open(id))      => Decision::Accepted(vec![Event::Opened(id)]),
        (true,  Reverse(e, r)) => Decision::Accepted(vec![Event::Reversed(e, r)]),
        _                      => Decision::Rejected { because: RejectReason::Illegal },
    }
}

Writing

Notes from the workshop.

Long-form notes on patterns, decisions, and the seams they leave behind. Drafted, not yet shipped.

Studio

A one-person workshop.

The short version of who runs the place and what kind of help this is.

Protoworks is a one-person engineering studio. Twelve years of shipped systems behind it: control planes, ledger cores, and build infrastructure that other teams keep using after the engagement ends.

Most of that capacity currently points at the studio’s own ventures — Strand, Ice Cream Boets, and Protoworks Defence — all pre-seed. The remaining time goes to a small number of outside engagements, usually multi-quarter, usually on the load-bearing layer other teams build on.

  • 2 engagements

    capacity

  • ~3 per year

    cadence

  • 12 yr

    shipping

Get notified

A note when something ships.

One quiet email when the studio opens its first engagement window, when notes go live, or when a venture ships. No newsletter cadence, no roadmap.

occasional notes when something ships · unsubscribe in one click

Contact

Reach the studio.

One email for engagements. Replies usually arrive inside a working week.

  • email

    rpeters@protoworks.dev

  • code

    github.com/protoworks-dev

  • notes

    protoworks.dev/notessoon