Execution client and node engineering
A node is not a product with users, it is infrastructure other people build on. Correctness and uptime are the whole deliverable, which is why we treat networking and consensus-adjacent code as protocol-grade rather than as application code that happens to run a chain.
Why this work is different
Everything above a client inherits its bugs. A sync path that is subtly wrong does not surface as a failed request. It surfaces months later as state that disagrees with the rest of the network, in someone else's product.
Public networks are also adversarial by construction. A node takes malformed input and hostile peers as normal operating conditions, so hardening against them is part of the build rather than a hardening pass at the end.
How we work
Client code is tested against real network conditions and instrumented so failures are observable rather than silent. A node that fails loudly at 3am is worth more than one that degrades quietly for a week.
Rust and Go are the working languages, chosen for the control over memory and concurrency that client internals demand, not out of preference.
What that means we build
Plugins and upgrades to existing clients rather than greenfield rewrites. Snap sync, P2P layer upgrades, transaction-pool and JSON-RPC improvements, and the research that backs them. This is work our founder has shipped in production, including P2P networking for a Starknet full node and internals for a Starknet block explorer, built at Nethermind.
Performance and reliability engineering. Profiling the hot paths, reducing sync time and memory footprint, and hardening the node against the input every public network eventually sends its way.
Common questions
- Which chains and clients do you work with?
- We work at the client-internals layer across EVM and Starknet ecosystems. Our founder built P2P networking for a Starknet full node and block-explorer internals at Nethermind, so Starknet infrastructure is a particular strength.
- What does node engineering actually involve?
- P2P networking, block and state sync, transaction pool management, JSON-RPC, and the performance and reliability work that keeps a full node fast and correct under real, sometimes adversarial, network load.
- Which languages do you use for client work?
- Primarily Rust and Go. The control they give over memory and concurrency is what client internals and high-throughput networking need.
Have something hard to build?
Tell us the hard part: the protocol, the client, the mechanism, or the system that has to hold.