Contract architecture
Design modular EVM systems with explicit trust boundaries, predictable upgrade paths, and carefully constrained permissions.
Staff Blockchain Engineer
Own the protocol layer.
Design secure Solidity systems and the Rust infrastructure around them for an independent team building on a new EVM ecosystem.
Building independently on Robinhood Chain.
SolidityRustEVMProtocol securityDistributed systems
Independent startup. This is not a role at Robinhood.
Protocol / execution / security
01 / The mandate
Build systems people can trust.
You’ll own critical smart-contract architecture and the infrastructure that makes it observable, testable, and safe to operate. This is a hands-on Staff role: set direction, make difficult technical decisions, and ship production code.
Rust infrastructure
Build reliable services for transaction orchestration, simulation, indexing, monitoring, and internal developer tooling.
Security by construction
Turn threat models and protocol invariants into tests, deployment gates, monitoring, and incident procedures.
Technical leadership
Define engineering standards, review critical changes, mentor senior contributors, and communicate trade-offs clearly.
02 / Ownership
Architecture, code, and the standard behind both.
Release pipeline / operational controls
- Own the architecture of production Solidity contracts and shared protocol components.
- Define trust boundaries, roles, upgradeability strategy, emergency controls, and operational safeguards.
- Build Rust services around contract execution, indexing, simulation, signing, monitoring, and data pipelines.
- Establish testing standards using unit tests, fuzzing, invariants, fork tests, and property-based testing.
- Lead threat modeling and prepare systems for external security review.
- Review protocol changes for storage, gas, economic, integration, and operational risk.
- Design safe integrations with RPC infrastructure, account abstraction, oracles, and cross-chain systems where required.
- Improve developer experience through reusable libraries, local environments, CI pipelines, and clear documentation.
- Mentor engineers while remaining directly involved in implementation.
Staff here does not mean architecture from a distance. You will be expected to write and review critical production code.
03 / Stack
Solidity at the core. Rust around the edges that matter.
The exact stack will evolve. We care more about engineering judgment than attachment to a particular framework.
Smart contracts
SolidityEVMFoundryHardhatOpenZeppelin patternsABI and storage layoutUpgrade and access-control design
Infrastructure
RustTokio / async systemsJSON-RPCTransaction simulationIndexingPostgreSQLQueues and event-driven services
Application layer
TypeScriptviem or ethersNode.jsAPI designInternal developer tools
Security and delivery
Fuzz testingInvariant testingFork testingStatic analysisDockerCI/CDMonitoring and alerting
Contracts
→Solidity / EVMExecution
Rust / asyncDecorative code specimen; not production-ready
// invariant: reserves cover every active claim
contract Settlement is AccessControl, ReentrancyGuard {
bytes32 public constant OPERATOR = keccak256("OPERATOR");
error InvalidState(uint8 current);
function execute(bytes calldata order)
external onlyRole(OPERATOR) nonReentrant
{
if (!_isValid(order)) revert InvalidState(state);
_settle(order);
}
}04 / Profile
Evidence matters more than keywords.
You do not need to match every line. You do need to demonstrate Staff-level judgment in systems where mistakes are expensive.
Core evidence
- You have shipped or substantially owned production Solidity systems.
- You can reason about EVM execution, storage layout, gas, calldata, signatures, proxies, permissions, and failure modes.
- You have practical Rust experience, or exceptional systems experience in C++ or Go with the ability to become productive in Rust quickly.
- You know how to convert protocol assumptions into testable invariants.
- You have participated in audits, security reviews, incident response, or high-risk production releases.
- You can design distributed services and reason about retries, idempotency, ordering, finality, and observability.
- You communicate architecture and trade-offs clearly to engineers and founders.
- You are comfortable working with incomplete information and making reversible decisions quickly.
Useful depth
Layer 2 or rollup systemsArbitrum ecosystemAccount abstractionCross-chain messagingFormal verificationCryptographic primitivesIndexers and blockchain data systemsTransaction simulationMEV-aware system designKey-management or signing infrastructureProtocol governance and upgrade operations
Strong Go or C++ engineers with production Solidity experience are welcome, but the role requires genuine interest in working deeply with Rust.
05 / First 90 days
Start with context. Finish with ownership.
Days 1–30
Map the system
- Review contracts, services, trust assumptions, and operational risks.
- Produce an architecture and threat-model assessment.
- Identify the highest-leverage technical improvements.
Days 31–60
Raise the baseline
- Improve testing, observability, and deployment controls.
- Ship one meaningful contract or Rust infrastructure improvement.
- Define engineering standards for critical protocol changes.
Days 61–90
Own the roadmap
- Take responsibility for a major protocol area.
- Align the team around a practical security and architecture roadmap.
- Create a repeatable path from design to review to safe production release.
06 / Why this role
High leverage without the layers.
Direct ownership
Own decisions that would be divided across several teams at a larger company.
Hands-on scope
Move between protocol design, Rust services, security review, and production delivery.
Senior collaboration
Work directly with founders and experienced technical contributors.
Build the foundation
Set patterns that future engineers and protocol components will inherit.
07 / Process
A technical process with a clear purpose.
- 01
Introductory call — 25 minutes
Context on the company, role, working model, and your goals.
- 02
Previous-work deep dive — 60 minutes
Walk through a system you designed or shipped. We care about decisions, constraints, failures, and lessons.
- 03
Protocol architecture session — 75 minutes
Collaboratively design a realistic system. No trivia and no puzzle-style algorithms.
- 04
Final team conversation — 45 minutes
Align on scope, expectations, communication, and mutual fit.
We aim to provide a clear decision shortly after the final conversation.
08 / Apply
Show us what you have built.
A concise application is enough. A repository, audit report, technical article, contract address, or architecture write-up is more useful than a long cover letter.
FAQ
Frequently asked questions
Is this a role at Robinhood?
No. This is a role at an independent startup building on public blockchain infrastructure. We do not claim employment, affiliation, partnership, or endorsement by Robinhood.
What is the company building?
An onchain protocol and infrastructure platform for the lifecycle of blockchain products. Qualified candidates receive a deeper product and architecture brief during the introductory process.
Is the role hands-on?
Yes. The engineer will define architecture and also write, test, review, and operate critical production code.
Is Rust mandatory?
Practical Rust experience is strongly preferred. Exceptional engineers with deep production experience in Go or C++ may be considered when they also have substantial Solidity expertise and are prepared to work deeply in Rust.
Can agencies submit candidates?
Direct applications are preferred. Agency submissions are considered only with prior written agreement.