sevnth Senior backend / blockchain engineer Available for new work

Systems that win races measured in milliseconds.

// latency-critical systems · built to win adversarial races

7+ years building high-concurrency systems that compete in real time: MEV searching, on-chain liquidations, and infrastructure where being slower or mispriced means losing outright.

View systems Get in touch

Languages

Go
Rust
Solidity
Huff
Python
TypeScript

Node status: healthy
p50 latency: 7.4ms
Events / s: 1,284
Uptime: 00:00:00
Services: 6/6

01 / whoami

Systems that survive live competition.

Based in Italy, open to remote and relocation. Seven years building latency-critical, high-concurrency systems, five of them hands-on across Ethereum and Solana: MEV searching, on-chain liquidations, smart contracts and real-time on-chain data infrastructure, owned end to end from hand-optimized bytecode to self-hosted nodes on bare metal.

My work lives in adversarial environments: Ethereum MEV, Solana liquidations, and, before crypto, reverse-engineering commercial bot-detection systems at a startup I co-founded and grew to eleven people.

Several of my projects became commercial products with paying users. I move into new technical spaces early, before the tooling exists, and instrument everything for evidence rather than intuition.

7⁺ Years in production 5+ on Ethereum and Solana

Builds: Solo, end to end: architecture, implementation, deploy, and the 3am pager.
Runs on: Own bare metal. No managed cloud, no SDK I can't read the bytes of.
Competes: Against funded teams for block inclusion. Against Akamai, DataDome and PerimeterX before that.
Fails: Atomically. Partial states get designed out rather than handled.
Proves it: Shadow mode first, then reconciled against what actually happened on-chain.
Timing: Tends to arrive in a category before the tooling for it exists.

Path

2021 - presentIndependent backend / blockchain engineerMEV searching, on-chain liquidations, smart contracts and real-time data infrastructure on Ethereum and Solana, plus automation products with paying users. Designed, built and operated solo.
2019 - 2021Co-founder and lead backend engineer, e-commerce automation startupA subscription platform with 400-500 paying subscribers, grown from two founders to a team of ~11. Technical direction throughout.

02 / how I build

Deadlines I don't control.

Checkout windows, market data, block slots: the clock belongs to someone else. Most of my work is making sure the expensive part already happened before the window opens, and that a slow dependency can't take the rest of the system down with it.

ingest → decide → execute → verify

Every system I ship is traced stage by stage, so I can see where the time actually goes instead of guessing. The hot path should spend its time on the network, not on assembly.

01

Ingest

high-volume streams

Real-time event and stream processing: binary protocol decoding, backpressure isolation, independent consumers per traffic class.
02

Decide

bounded, cheap, honest

Decisions made against live state with explicit limits, so a bad input degrades the outcome instead of the system.
03

Execute

precomputed, atomic

Work assembled ahead of the deadline and committed as one atomic operation, with no partial-failure states to clean up afterwards.
04

Verify

predicted vs actual

Post-execution reconciliation of what I expected against what happened. It has overruled my own assumptions more than once.

Stage latency · p50

End-to-end 52ms · re-sampled continuously

Ingest 8ms
Decide 17ms
Execute 27ms
Verify 52ms

03 / internals

Where the abstractions end.

Two habits that show up in everything I build: read the bytes yourself rather than trust a vendor struct that will drift, and assume every outbound dependency will eventually hang on you.

rust

// decode.rs: fixed-offset parser
0x0000  07 f4        MAGIC        // asserted, never assumed
0x0002  03           VERSION      // layout v3
0x0003  a19c…7f      OWNER        // 32 bytes
0x0023  0000000001   SLOT         // u64 le
0x002b  3f8e         EXPONENT     // i16
0x002d  1d4c…00      AMOUNT       // u128 le
0x003d  01           STATUS       // 1 = active
0x003e  0000         _pad         // alignment
0x0040  6b21…9a      UPDATED_AT
0x0048  c8 04        CHECKSUM     // verified before use

// vendor structs drift on upgrade.
// byte offsets do not.

// breaker.go: one slow dependency must not stall the pipeline
func (b *Breaker) Do(ctx context.Context, call func() error) error {
    if b.open() {
        return ErrCircuitOpen        // fail fast, don't queue
    }

    ctx, cancel := context.WithTimeout(ctx, b.perCall)
    defer cancel()

    if err := call(); err != nil {
        b.fails.Add(1)
        if b.fails.Load() >= 3 {
            b.trip(b.cooldown)      // 3 in a row: cut it loose
        }
        return err
    }
    b.fails.Store(0)
    return nil
}

04 / selected systems

Built solo. Run live.

A self-directed research project into how competitive searcher infrastructure really works: a modular multi-strategy bot running cross-DEX arbitrage, just-in-time concentrated liquidity on Uniswap V3 and mempool-driven strategies, built to compete with established searcher teams for block inclusion and instrumented to find out whether it did.

The hard part is staying profitable, not finding opportunities: bids are priced against live baseFee and builder competition on expected value net of gas and builder tip, with tips capped so gas can never overshoot gross profit.

Five-layer loss-prevention stack ending in a profit guard inside the Huff executor: it re-reads the balance at the end of execution and reverts the whole bundle at zero cost, saving ~46,000 gas per bundle and defending against malicious token transfer hooks.

Hand-written Huff executor with msg.value-based dispatch across 22 commands: V2/V3 swaps, V3 mint, burn and collect for JIT positions, and Balancer V2 flashloans for zero-capital arbitrage.

Real-time mempool decoding across 20+ routers and aggregators (Uniswap Universal Router, 1inch, 0x, KyberSwap, PancakeSwap, ParaSwap, Balancer V2), including aggregator split detection from raw calldata.

Dual-path simulation (local Reth, health-probed every 30s, with Flashbots fallback) and concurrent submission to 5 builder relays, each behind its own timeout and a circuit breaker that trips after 3 consecutive failures.

Shadow mode, per-strategy inclusion rate and P&L, stage-level latency tracing (detect → evaluate → build → submit), automatic disable on a rolling 1-hour loss, and realized on-chain PnL kept apart from pre-trade estimates. A live strategy was paused on this evidence.

Self-hosted Reth + Lighthouse on bare metal behind a custom low-latency RPC layer, with debug_traceCall turning opaque reverts into structured causes for post-mortems.

Go
Huff
Reth
Lighthouse
Flashbots
Uniswap V2/V3
Balancer V2
Production liquidation bot competing for sub-slot execution priority, where the winner is decided by a few hundred milliseconds of latency and pricing accuracy.

Three concurrent loops at different time scales: slow bulk position scan, sub-second oracle refresh, and execution. Transactions for at-risk positions are pre-built before they become eligible, so the hot path spends its time on the network, not on assembly.

Competitor detection via Jito ShredStream surfaces rival attempts ~400ms before confirmation, feeding configurable strategies: raise the bid and race, or abandon a target that is already taken.

Fully atomic liquidation in one V0 transaction with Address Lookup Tables: flash-borrow → refresh → liquidate → swap (Jupiter route or direct Orca Whirlpool) → flash-repay. No inventory risk, no working capital.

Redundant broadcast in parallel: TPU UDP with leader caching, shotgun RPC, Jito bundles with profit-proportional tips and staked-weighted QoS, plus a 25ms resend fallback and confirmation polling.

Accounts parsed at fixed byte offsets rather than SDK structs; three independent gRPC streams keep high-frequency oracle traffic from back-pressuring reserve updates. Live WebSocket dashboard for metrics, controls and alerts.

Rust
Yellowstone Geyser
Jito
ShredStream
Jupiter
Orca
Multi-user trading bot with real-time mempool ingestion and ABI-level decoding of pending transactions to detect liquidity adds, co-bundling buys to land in the same block as the liquidity.

Anti-rug layer: fork-state simulation of a full buy/sell round trip, tax detection via balance-delta accounting, bytecode pattern matching, and liquidity-lock verification.

Per-user wallets: BIP-32 derivation, AES-GCM encrypted key storage, dedicated RPC routing, private submission via Flashbots Protect.

Full trading interface: take-profit and stop-loss ladders, slippage and priority-fee tuning, multi-wallet copytrading, and live P&L reconciled against on-chain balances.

Go
Flashbots Protect
BIP-32
AES-GCM
A two-contract system, a master factory plus per-user deployable contracts, so each user deploys and exclusively controls their own on-chain instance: single and bulk mint, mint-and-transfer, bulk transfer, custody withdrawal and burn.

Hand-tuned at the opcode level to minimise per-token gas, the economic point of the system: in a competitive mint, batching N operations into one optimized call beats N independent transactions on both cost and speed.

Used personally and sold as private access to other operators, at a time when very few comparable implementations were in circulation.

Solidity
Factory pattern
Opcode-level gas tuning
A commercial cross-chain NFT automation product: bulk minting, transfers and floor sweeping via OpenSea on EVM chains and Topaz on Aptos.

200 paying subscribers, a cap set deliberately to protect performance and support quality, after a public beta of ~150 users. Paying users from launch day, when only a handful of comparable tools existed worldwide.

V3 rewrite moved the execution layer from Python to Go (goroutines and worker pools) for sub-block reactivity, and replaced the CLI with an Electron desktop GUI.

Replaced database-backed credentials with an on-chain membership model: access gated by NFT ownership, verified through EIP-712 signed messages, with membership tokens airdropped to members. No central credential store, and access moves between users without an administrator.

Go
Python
Electron
EIP-712
OpenSea
Topaz
Co-founded and led engineering for a subscription platform serving 400-500 paying subscribers; grew from two founders to a team of ~11 (4 engineers, 6-7 in operations and support) and owned technical direction throughout.

Fully autonomous checkout across 40+ retailer integrations: real card payments (Visa, Mastercard) through multiple PSPs, automated 3-D Secure (3DS/3DS2), tokenization, address and shipping selection, and order confirmation parsing. Hundreds of completed checkouts per release event.

In-house real-time monitoring that found items by keyword or product identifier, tracked variant-level stock across retailers and triggered checkout the instant stock appeared, with a fallback that secured whichever variant was available.

Protocol-level reverse engineering: HTTP/TLS analysis and interception, request-signature replication, and mobile app backends whose private APIs proved more reliable than the web stack.

Worked against evolving commercial bot detection (Akamai, DataDome, PerimeterX), with proxy rotation, CAPTCHA-solver integration and distributed task scheduling.

Built from zero across three architecture generations: Python CLI → Flask app with a per-user local dashboard → high-concurrency Go rewrite with an Electron GUI.

Go
Python
Flask
Electron
TLS analysis
3DS2

05 / shipped as

Products, not repos.

Two of these went out under their own name, with their own users, their own support load, and their own outages. That changes how you build.

Wyvern

formerly NFT Finesser · 2021 - 2023

cross-chain NFT automation

Bulk minting, transfers and floor sweeping across Ethereum, L2s, Canto and Aptos, via OpenSea and Topaz. Shipped first as a Python CLI, later rewritten around a Go execution core behind an Electron GUI.

Paying subscribers: 200capped on purpose
Public beta: ~150users before launch
Revenue from: Day 1paying users at launch

Modules

smart-contract minting
unverified contracts
queued tx · same block
merkle / signature mints
on-chain gas estimator
bulk speed-up & cancel
send on pending
flip mode
quicktasks
custom RPCs
Flashbots
hexdata
supply monitor
marketplace sniping
distribute & recollect
on-chain monitors → Discord
HWID-bound licensing

Fleek

Fleek Framework · 2019 - 2021

e-commerce checkout automation

The checkout engine behind the startup, built on a Go execution core behind an Electron GUI: real card payments across multiple PSPs, automated 3DS2, and a permanent arms race against commercial bot detection.

Paying subscribers: 400-500subscription platform
Retailers: 40+live integrations
Team: ~11grown from two founders

Modules

40+ retailer integrations
multi-PSP card payments
3DS / 3DS2 automation
tokenization
variant-level monitors
instant-restock trigger
proxy rotation
CAPTCHA solving
distributed task scheduling
TLS / HTTP fingerprinting
mobile private APIs
per-user dashboards

06 / stack

Grouped by domain, not by buzzword density.

The full stack of things I have actually shipped. Everything here has run in production against real money, or real adversaries.

Languages

[languages]

Go
Python
Solidity
Rust
Huff
TypeScript
JavaScript
SQL
Bash
Yul
HTML/CSS

Backend

[backend]

goroutines & worker pools
event-driven
pub/sub
circuit breakers
backpressure
gRPC
WebSocket
JSON-RPC
idempotency
hot-path tuning
retries + jitter
zero-downtime migration

Real-time

[realtime]

gRPC streaming
UDP
consumer isolation
binary protocols
fixed byte offsets
protobuf
sub-ms hot paths
leader-aware routing
multi-path broadcast
stage tracing

EVM

[blockchain.evm]

EVM internals
EIP-1559 fee markets
searcher infra
cross-DEX arbitrage
JIT liquidity
bundle pricing
Flashbots
builder relays
Reth
Lighthouse
Uniswap V2/V3
Balancer V2
flash loans

Solana

[blockchain.solana]

Yellowstone Geyser
Jito ShredStream
slot tracking
V0 transactions
Address Lookup Tables
TPU broadcast
Jito bundles
Kamino Lend
Jupiter
Orca Whirlpool

Contracts

[contracts]

ERC-20 / 721 / 1155
EIP-712
EIP-2612
factory
proxy / clones
hand-written Huff
Yul
opcode-level tuning
storage packing
Foundry
invariant testing

Security

[security]

economic exploit research
MEV attack surfaces
anti-rug simulation
bytecode pattern matching
tax/honeypot detection
profit guards
BIP-32/39 derivation
AES-GCM at rest

Reverse engineering

[reverse_engineering]

HTTP/1.1 + HTTP/2
TLS fingerprinting (JA3/JA4)
mitmproxy
Wireshark
Frida
APK/IPA analysis
Akamai Bot Manager
DataDome
PerimeterX
certificate pinning bypass

Payments

[payments]

card payments (Visa/Mastercard)
multi-PSP routing
tokenization
3-D Secure 1 & 2
end-to-end checkout
failure recovery

Infrastructure

[infrastructure]

Hetzner bare metal
Linux
Docker
systemd
nginx
kernel/network tuning
PostgreSQL
Redis
SQLite
latency histograms
shadow mode

Frontend

[frontend]

Electron desktop apps
Angular
Ionic
React
real-time dashboards
Telegram bots
CLI tools
iOS/Android releases

Product

[product]

subscription products
licensing
on-chain access control
co-founder
engineering lead
team of ~11
incident response
deliberate growth caps

sevnth@hetzner · zsh~/skills.toml · read-only

➜ ~ cat skills.toml
# sevnth: full stack of things I have actually shipped
# grouped by domain, not by buzzword density

[languages]
primary   = ["Go", "Python", "Solidity"]
secondary = ["Rust", "Huff", "TypeScript", "JavaScript"]
also      = ["SQL", "Bash", "Yul", "HTML/CSS"]

[backend]
concurrency = ["goroutines", "worker pools", "channels",
               "mutex/atomics", "async pipelines"]
patterns    = ["event-driven", "pub/sub", "queues",
               "circuit breakers", "backpressure",
               "graceful degradation"]
apis        = ["REST", "WebSocket", "gRPC", "JSON-RPC", "webhooks",
               "rate limiting", "idempotency"]
performance = ["profiling", "allocation reduction",
               "hot-path tuning", "batching", "caching",
               "connection pooling"]
reliability = ["retries + jitter", "timeouts per dependency",
               "atomic ops", "replay pipelines",
               "zero-downtime migration"]

[realtime]
streams  = ["gRPC streaming", "WebSocket", "SSE", "UDP",
            "stream multiplexing", "consumer isolation"]
decoding = ["binary protocols", "fixed byte offsets",
            "ABI decoding", "protobuf", "custom serializers"]
latency  = ["sub-ms hot paths", "precomputation",
            "leader-aware routing", "multi-path broadcast",
            "stage tracing"]

[blockchain.evm]
core  = ["EVM internals", "gas mechanics", "state access",
         "reverts & tracing", "EIP-1559 fee markets"]
mev   = ["searcher infra", "cross-DEX arbitrage",
         "JIT liquidity", "mempool strategies",
         "bundle pricing"]
infra = ["Flashbots", "builder relays", "private orderflow",
         "Reth", "Lighthouse", "custom RPC layers"]
defi  = ["Uniswap V2/V3", "Balancer V2", "1inch", "0x",
         "KyberSwap", "ParaSwap", "flash loans"]

[blockchain.solana]
streaming = ["Yellowstone Geyser", "Jito ShredStream",
             "account subscriptions", "slot tracking"]
execution = ["V0 transactions", "Address Lookup Tables",
             "TPU broadcast", "Jito bundles", "priority fees"]
protocols = ["Kamino Lend", "Jupiter", "Orca Whirlpool",
             "oracle refresh", "liquidations"]

[contracts]
standards    = ["ERC-20", "ERC-721", "ERC-1155", "EIP-712",
                "EIP-2612"]
patterns     = ["factory", "proxy / clones", "access control",
                "reentrancy guards", "pull payments"]
optimization = ["hand-written Huff", "Yul", "opcode-level tuning",
                "storage packing", "calldata compression"]
tooling      = ["Foundry", "Hardhat", "forge test",
                "fork simulation", "invariant testing", "Tenderly"]

[security]
offensive = ["economic exploit research", "MEV attack surfaces",
             "simulation-based validation"]
defensive = ["anti-rug simulation", "bytecode pattern matching",
             "tax/honeypot detection", "profit guards"]
keys      = ["BIP-32/39 derivation", "AES-GCM at rest",
             "hardware wallets", "signature verification",
             "nonce management"]

[reverse_engineering]
protocol = ["HTTP/1.1 + HTTP/2", "TLS fingerprinting (JA3/JA4)",
            "frame ordering", "header order replication"]
tooling  = ["Charles", "mitmproxy", "Wireshark", "Frida",
            "APK/IPA analysis", "traffic interception"]
antibot  = ["Akamai Bot Manager", "DataDome", "PerimeterX",
            "canvas/WebGL fingerprints", "behavioural signals"]
mobile   = ["private API discovery",
            "certificate pinning bypass",
            "request signing replication"]

[payments]
flows      = ["card payments (Visa/Mastercard)",
              "multi-PSP routing", "tokenization",
              "3-D Secure 1 & 2"]
automation = ["end-to-end checkout", "challenge resolution",
              "order confirmation parsing", "failure recovery"]

[infrastructure]
hosting       = ["Hetzner bare metal", "dedicated servers",
                 "colocation-grade tuning", "VPS fleets"]
ops           = ["Linux", "Docker", "systemd", "nginx",
                 "kernel/network tuning", "firewall & isolation"]
observability = ["structured logging", "live WebSocket dashboards",
                 "alerting", "latency histograms", "shadow mode"]
data          = ["PostgreSQL", "Redis", "SQLite",
                 "time-series storage", "snapshot + replay"]
network       = ["proxy rotation (residential/datacenter)",
                 "low-latency routing", "private endpoints",
                 "failover"]

[frontend]
shipped    = ["Electron desktop apps", "Angular", "Ionic", "React",
              "real-time dashboards"]
interfaces = ["Telegram bots", "CLI tools", "local web dashboards",
              "iOS/Android releases"]

[product]
commercial = ["subscription products", "multi-tenant isolation",
              "licensing", "on-chain access control"]
leadership = ["co-founder", "engineering lead", "team of ~11",
              "hiring", "technical direction", "incident response"]
operating  = ["paying users from launch day", "support at scale",
              "deliberate growth caps"]

# everything above has run in production against
# real money, or real adversaries.
➜ ~

07 / handshake

Let's build something hard to copy.

Open to remote work and relocation. The problems I'm most useful on are the ones with a clock attached: latency budgets, adversaries who adapt, and operations that must not half-succeed.

If that's your problem, the fastest way in is an email with the constraint that's hurting. I answer those first.

Status: available for new work
Based: Italy · CET (UTC+1)
Mode: remote · relocation · contract
Reply: usually within a day
Languages: Italian · English
Primary stack: Go · Python · Solidity

admin@sevnth.dev

Click copies the address and opens your mail app.

Systems that win races measured in milliseconds.

Ingest

Decide

Execute

Verify

2026 - present Multi-Strategy MEV System Ethereum mainnet

2026 - present Kamino Lend Liquidation Bot Solana mainnet

2024 Multi-User Telegram Trading Bot Ethereum mainnet

2023 NFT Bulk Minting & Transfer Contract Suite Ethereum

2021 - 2023 Cross-Chain NFT Automation Bot ETH · L2s · Canto · Aptos

2019 - 2021 E-commerce Automation Startup Co-founder · Lead eng

Wyvern

Fleek

Languages

Backend

Real-time

EVM

Solana

Contracts

Security

Reverse engineering

Payments

Infrastructure

Frontend

Product

Let's build something hard to copy.