Go Engineering Consultancy

Pigfox LLC is a Go engineering consultancy, operating since 2005. I'm Peter Sjolin, and I build the backend: distributed services, the queues and pipelines behind them, and the parts that have to keep working when a dependency does not. Everything below is either running on this site or shipped for a client.

The record

More than fifteen years of backend engineering, seven of them writing production Go. The work has been distributed systems and the services between them — gRPC and REST APIs, Kubernetes-based deployments, message queues carrying real volume — and, in two regulated settings, payment processing and healthcare claim adjudication pipelines, where being wrong quietly is the expensive failure. More recently that has extended to blockchain and zero-knowledge integration.

Pigfox LLC is incorporated in Nevada and works with clients wherever they are. The company's operating history and my own engineering record are two different spans; the numbers above are mine.

What I build

  • Backend services in Go. APIs, workers and the plumbing between them — typed, tested, and deployed. Not a prototype handed over with a README.
  • Durable job pipelines. Work that must survive a restart belongs in a queue, not a request. I run Postgres-backed queues with retries, error handlers and a dead-letter path, so a timeout recovers instead of failing a user.
  • Concurrency that behaves under load. Bounded queues, backpressure, cancellation that actually cancels. Most production Go problems are not throughput problems; they are what happens at the edges.
  • Systems integration. Payment providers, third-party APIs, chain RPC, whatever the business already depends on — wired in with the failure modes handled rather than discovered later.
  • Diagnosis of an existing system. Profiling, tracing and reading the code you already have, to say plainly where the time and the risk are.

The evidence

The strongest thing I can offer is not a claim, it is a running system you can open. Every demo below is live, and each one exists because it shows a technique that is hard to describe and easy to see. They are the portfolio — the full set is here.

  • Concurrency and cancellation. Goroutine Visualizer runs real goroutines and real channels in this server and shows what a cancelation cannot reach. Backpressure Lab pushes a bounded queue past its capacity under three overflow policies. pprof Lab shows what a block profile sees that a CPU profile cannot.
  • Distributed state and Kubernetes. Reconcile Lab is a controller loop and a competing writer reaching for the same object, built on the real k8s.io object and error types, showing what a reconciler does when a write is refused.
  • Blockchain and zero-knowledge. ZK Escrow releases funds on a Groth16 proof. ZK KYC Pass proves a credential without revealing an identity. RWA Tokenization gates every transfer on an on-chain whitelist. All live on Base Sepolia.
  • Contract engineering. Gas Optimization races two implementations with a compiler-enforced identical interface. Interest Rate Model is an immutable lending curve read straight off the chain. Oracle Health Explorer names what is actually wrong with a price feed.
  • Verification without a chain. Cosmos Lab replays a signed header and two chained ICS-23 proofs offline, and refuses a single flipped bit.
  • WebAssembly. Orbit Lab propagates a thousand orbital objects a frame in the browser. WASM Keygrind grinds EVM vanity addresses with the network disconnected.

The contracts behind those demos go through one pipeline before anything is deployed: a lint stage, a doctrine gate, an address-checksum check, a size gate, the full test suite, complete line, statement, branch and function coverage, Slither at its lowest severity threshold, and two independent invariant fuzzers whose registered property counts must agree with a declared number. It is a public repository, so you can read the gates rather than take my word for them.

Two specialisms, written up separately

Two parts of this work have their own pages, because they are deep enough to deserve one. Production LLM engineering in Go covers the orchestration layer around a model — queues, approval gates, schema-constrained outputs, cost tiering. Automation covers the unattended pipelines, including the one that publishes this site's blog every day without anyone at the keyboard.

Working together

I work solo and end to end, which suits a defined problem better than an open-ended staffing arrangement: a service to build, a pipeline to make reliable, an existing system to diagnose, or an integration that keeps breaking. Small enough to start quickly, and scoped so you can tell whether it worked.

If that fits something you are trying to get built, get in touch.