Remote first (must be based within CET +/- 3 timezones) | Full-time
About Arkiv
Blockchain data is hard to use. Developers store data on-chain, then immediately need indexers, subgraphs, and custom infrastructure just to query it back. We think that's broken.
Arkiv is fixing it at the protocol layer - a blockchain with queryable storage built in. SQL like queries against on-chain data, no external indexing required. It's a different architecture, and it doesn't exist anywhere else yet.
We're a small, focused team preparing for mainnet launch. If you want to build the web apps that developers and users will use to interact with foundational Web3 infrastructure, this is the moment.
The Role
You're a fullstack engineer who lives at the intersection of smart contracts and web apps. You read Solidity well enough to integrate any contract, debug a failed transaction by inspecting calldata, and ship a Bridge UI that handles network switching, wallet quirks, and stuck transactions without falling apart.
You will own Arkiv's flagship dApp surface — the Bridge UI that moves tokens between L2 and L3. You'll own smart-contract integration across user-facing surfaces, set the quality bar for Web3 UX, and build the client-side observability that tells us what users actually experience.
This is a hands-on technical role with clear paths to grow depth and broaden scope — not a stepping stone into management. You will write production TypeScript or JavaScript, ship Solidity helpers when needed, and own these surfaces end-to-end. Over time you can deepen as the team's Web3-UX and smart-contract-integration expert, or broaden into operations / SRE or Solidity / contract authorship. We grow engineers via scope and depth, not headcount.
You pair with the team's other Webapp Engineer, who primarily owns developer onboarding (docs, faucet, sample apps), the homepage, and the L3 explorer. Clear primary scope, mutual backup — no user-facing surface has a single point of failure on the team. You also work closely with the Head of Platform (or CTO, if you're one of our first hires), the Protocol team on contract integration and SDK shape, and DevRel on developer onboarding.
What You'll Own
Bridge UI: L2 L3 token transfer app: wallet connect, network switching, signing, status tracking, edge-case handling (stuck txs, RPC failures, dropped wallets)
Smart-contract Integration: ABI integration across user-facing surfaces; debugging failed transactions (Tenderly or similar); writing minor Solidity in Foundry (faucets, helpers); pairing with the Senior Solidity Engineer on bridge / AA flows
dApp Quality: Code review across user-facing code; setting the standard for Web3 UX, accessibility, and resilience
Web3 Observability: Client-side telemetry, wallet-error tracking, transaction-success dashboards
Backup coverage: developer onboarding (docs, faucet, sample apps), homepage, and L3 explorer (Blockscout) ops — your partner's primary scope, your secondary.
Who You Are
Character and drive matter more than your CV.
You are genuinely curious. You read Solidity for fun. You know what a failed transaction looks like on Etherscan, and you've probably written a custom decoder for one.
You are hands-on. You write production TypeScript or JavaScript daily. You debug RPC issues. You know which wallet has which bug. You don't wait for a Bridge UI spec — you sketch the flow, get feedback, ship a v1, iterate.
You have high standards for user-facing code. Web3 UX is hard and most dApps are bad. You can explain why a confirmation step matters, why an error message should mention gas, why retry-with-bumped-nonce isn't optional.
You see beyond your lane. A weird RPC response. A confusing docs example. A contract that's hard to integrate. You raise it, and often you help fix it.
You collaborate well. You pair-program with Senior Engineers, give SRE useful client-side signals, and help DevRel turn protocol details into onboarding material that works.
You're ready to grow — deeper in Web3 UX, broader into ops or Solidity. Either way, you're not standing still.
What We Expect
Ship the Bridge UI: Production-grade, resilient to Web3 weirdness — wallet quirks, RPC failures, stuck transactions
Read contracts: Solidity at reading proficiency is non-negotiable; you can write minor contracts (faucet, helpers) when needed
Measure what users see: Client-side observability is your responsibility — wallet errors, RPC failures, transaction success rates
Set the quality bar: Code review and standard-setting for Web3 UX across the team
Cover your partner: Back up the other Webapp Engineer during absences (docs, faucet, sample apps, homepage, L3 explorer ops)
Collaborate across teams: Protocol on contract integration, SRE on infrastructure, DevRel on onboarding
Technical Requirements
TypeScript / JavaScript: 5+ years production experience; modern JS or TS; shipped real applications, not prototypes
Web stack: Hands-on production experience with a major frontend framework (React, Vue, Svelte, or similar) and Node.js on the backend; we're not dogmatic but you know one combination well
Web3 frontend: wagmi, viem, ethers.js or equivalents; you've integrated multiple wallets (MetaMask, WalletConnect, hardware) and know their quirks
EVM & contract integration: Read Solidity fluently; integrate ABIs, debug failed transactions (Tenderly or similar), decode calldata; understand gas, nonces, replacement transactions
Solidity (writing): Comfortable writing minor contracts (faucets, helpers) in Foundry (forge, cast, anvil)
Web3 standards: EIP-1559, EIP-712 (typed data signing), ERC-20/721/4626, account abstraction (ERC-4337) basics
Testing: Frontend (component + integration) and contracts; Web3 UX needs tests because Web3 surprises happen
Strong Plus:
Prior bridge UI or cross-chain dApp experience
Account abstraction integration (ERC-4337 / sponsored transactions)
Open-source contributions to wagmi, viem, ethers, Foundry, or similar
Solidity production beyond integration (audit prep, gas optimization, security-conscious patterns)
Blockscout operations experience
Experience with docs platforms (Docusaurus, Mintlify, custom)
We know this list is demanding. If you're a strong dApp engineer and most of it resonates, we encourage you to apply.
Growth Path
This role grows via technical depth and broader scope — not headcount.
Principal dApp Engineer: Deepen as the team's expert on Web3 UX, smart-contract integration, and dApp resilience; set the bar via review and pairing.
Broaden into Operations / SRE: Take on more of the production surface — incident response for user-facing systems, advanced client-side observability and SLO ownership, Blockscout-grade infra, on-call. Scope expands into the Platform team's SRE space.
Broaden into Solidity: Grow from minor contracts to owning meaningful smart-contract surface — bridge, AA, or gas reimbursement — and join audit cycles. Scope expands into the Protocol team's Senior Solidity Engineer space.
How We Work
Ownership: See a problem, own it - follow through or escalate.
Direct feedback: We challenge ideas openly and say what we mean.
Ship fast, learn faster: Simple solutions, quick iterations, mistakes are data.
Stay close to users: Decisions grounded in real signals from customers and the larger Web3 community, not assumptions.
Location & Compensation
Arkiv is building infrastructure for a more open internet. If this sounds like you, we'd love to talk.
