A blocking integration should not be the reason you miss your launch.
EpochFi Labs helps startups and protocol teams design, build, integrate, and harden production financial systems on Solana. Senior-led Rust engineering, with one engineer accountable for the whole system — not a ticket queue.
Most prototypes model steps 1 and 2. Production systems lose money at step 3. The work is designing 4 and 5 before an incident forces you to.
Your system has 400 ms to be right.
In plain terms: I am the senior engineer teams bring in when their Solana product has to work with real money.
Typically three to fifty people, pre-seed to Series A, with money or user positions already moving through the system — or about to be.
The point where shipping fast stops being enough.
If one of these describes your position, the conversation is usually short and specific.
An exchange, venue, or protocol integration is blocking your launch.
Third-party APIs fail in ways documentation does not describe: partial fills, silent rejections, duplicate acknowledgements, geo-blocks, sockets that stay open for hours while sending nothing. I have built and repaired integrations across seven venues, and I know which failure modes must be designed for before launch rather than after.
Your prototype works, but it is not ready for real money or real users.
A demo only has to succeed once. A production financial system has to be correct when a transaction is dropped, a worker restarts mid-operation, or a venue returns a state you did not anticipate. That gap is architecture, not effort.
Orders, transactions, or positions get stuck when something external fails.
Stuck state is expensive twice: once in exposure, once in the engineering hours spent reconstructing what happened. The fix is idempotent operations, an explicit source of truth, and recovery paths that run without a human deciding what to do.
You need senior Rust or Solana expertise without making a permanent hire.
Hiring a senior Rust engineer in this domain takes months and commits you to a salary before you know the shape of the work. An engagement gives you the same seniority on a defined scope, and ends when the work is done.
AI is generating more code than your team can safely review.
Generated Rust usually compiles and often passes the happy path. What it rarely gets right is concurrency, error propagation, state consistency, and what should happen when a call fails halfway. I review that code and the architecture around it.
Four areas of work
Most engagements combine two of these: build the thing, then make it survive production.
Solana & Rust engineering
Anchor programs, the Rust backend services around them, and the instruction-building SDKs your clients call — written to be read and maintained by your team after I leave.
- Anchor program development
- Rust backend services (Axum, Tokio)
- Protocol integrations
- Instruction builders & client SDKs
- Transaction construction & submission
- Account & state architecture
- Geyser / Yellowstone gRPC pipelines
- Performance & compute optimisation
DeFi & trading infrastructure
The parts of a financial product where correctness is commercial: what a position is, when it settles, and what happens when a venue disagrees with you.
- Order & position lifecycle management
- DeFi protocol integrations
- Exchange & liquidity venue integrations
- Liquidation workflows
- Settlement & reconciliation
- Market-data & price-feed services
- Real-time event processing
- Perpetuals, AMMs & prediction markets
Architecture & production hardening
A read of the system as it actually is, followed by a prioritised plan to make it dependable. Engineering review, not a formal security audit.
- Architecture & codebase reviews
- Concurrency & async Rust analysis
- Failure recovery design
- Idempotency & state consistency
- Testing strategy
- Monitoring & operational tooling
- Incident investigation
- Production-readiness review
Embedded technical leadership
For founders without a senior engineer in the room: someone accountable for technical decisions, and able to explain them commercially.
- Fractional technical leadership
- Senior individual-contributor support
- Architecture ownership
- Technical planning & roadmapping
- Code review, including AI-generated code
- Engineering-process improvement
- Mentoring & decision support
Two production Rust systems
Both sit behind a live mobile perpetuals and prediction-market product on Solana. Repositories are private; technical detail available under NDA.
A price platform that degrades instead of going dark
A mobile trading product needed prices from seven heterogeneous venues, on-chain and off, delivered to phones fast enough to trade against. Each venue fails differently, and a chart that freezes or lies is a support ticket at best and a bad fill at worst.
Sole engineer on the service: protocol specification, venue ingestion, storage design, deployment topology, and the operational tooling around it.
Independent Tokio tasks per venue with backoff reconnect and liveness watchdogs, funnelling into a bounded channel that deliberately drops stale ticks under backpressure — the correct failure mode for price data. Per-symbol transport precedence lets on-chain marks own a symbol while fresh and hand back to the venue socket when they age out, so an outage degrades quality rather than emptying a chart. A database-driven market registry means new markets go live without a deploy. Prices are served over a documented WebSocket contract with snapshot-first ordering guarantees, so the mobile client needs no buffering, deduplication, or staleness logic of its own.
Removed the single-transport dependency behind price outages, cut on-chain ingress roughly eightfold by slicing account frames server-side, and made market listing an operational action rather than an engineering one. 263 tests, none ignored, including wire-protocol assertions taken directly from the specification.
Funds-safety engineering on a live derivatives backend
Real money moving through perpetuals, a hosted-perps router across four venues, prediction markets, and a high-leverage sixty-second game — with custodial wallets and no tolerance for a position ending in an unknown state.
Backend architecture and delivery: transaction construction, job execution, venue integrations, reconciliation tooling, and post-incident redesigns.
Every high-risk module states the invariant it protects. The market registry fails closed rather than defaulting to a wrong account slot. Withdrawal sweeps only write a terminal record after funds are confirmed home; on exhaustion the position stays open, ops are alerted, and a reconciler re-enqueues it. Protective stop and take-profit legs are placed and confirmed before the previous ones are cancelled, so a failed reset can never strip existing protection. Expiry and liquidation are made mutually exclusive by a database write-fence. A gasless-transaction incident was closed by re-specifying the budget in terms of confirmed sponsorships and deploying it under a new key namespace, so stale semantics could not survive the release.
Introduced deterministic recovery paths across every funds-moving workflow, replaced silent defaults with explicit refusals, and gave the team paging that fires once per incident instead of not at all. A real-funds mainnet harness with cent-level conservation assertions makes release verification repeatable rather than a judgement call.
[VERIFY] Testimonial from Asymmetra Labs — two or three sentences on what was delivered and what changed as a result. Ask for something specific rather than complimentary.
Three ways to start
Most clients begin with a review, because it makes the rest of the work accurately scopeable.
A focused assessment of an existing codebase, architecture, integration, or production concern.
- Technical findings
- Risk assessment
- Prioritised recommendations
- Remediation plan
- Architecture diagrams
- Implementation roadmap
A defined engagement to build a specific subsystem, integration, protocol component, or production improvement.
- Discovery
- Architecture
- Implementation
- Testing
- Deployment support
- Documentation & handover
Ongoing senior engineering support for teams that need architectural and delivery ownership alongside their own engineers.
- Part-time or full-time
- Monthly retainer
- Architecture ownership
- Code & AI-code review
- Technical planning
- Rolling monthly renewal
[VERIFY] Indicative pricing sits well here — a single "from" figure per model filters enquiries before they reach your calendar. Add it once you are comfortable publishing numbers.
How I build systems that hold money.
Five principles that decide most of the design work before any code is written.
Name the source of truth
For every piece of state — a position, a balance, an order — one system decides. Everything else reconciles towards it. Ambiguity here is the root of most financial-system incidents.
Fail closed, never on a default
A lookup that cannot answer must refuse the work, not guess. Silent defaults in a funds path are how one market's position ends up written against another's account.
Design recovery, do not improvise it
Partial failure is a normal operating condition, not an exception. Idempotency keys, reconciliation sweeps, write-fences, and compensating actions belong in the design, so recovery does not depend on who is awake.
Instrument for the incident you will have
Logs, metrics, and alerts built around the business workflow rather than the request. The test is whether one engineer can answer "what happened to this order" in minutes, and whether anyone gets paged when the answer is bad.
Leave your team able to own it
Written specifications, documented decisions, tests that describe intent, and a handover walkthrough. The engagement is finished when the system does not need me.
neutral, no crypto backdrop
Liam Faruq
Founder & principal engineer, EpochFi Labs Ltd · London
I spent the first part of my career inside bank technology: trade-event feeds and data services at RBS and NatWest Markets, then rates pre-trade pricing at JP Morgan, building concurrent Java systems for OIS, swaps and swaptions. After that, full-stack work on a consumer lending platform, and FX and commodities settlement tooling in Rust at Caplin Systems. Since 2024 I have worked exclusively in Rust and Solana, contracting with protocol and trading teams.
That sequence is the point of EpochFi Labs. Trading, settlement and reconciliation have well-understood failure modes in traditional finance, and much of the Solana ecosystem is rediscovering them at cost. I bring that discipline into on-chain engineering, without the overhead of a large consultancy.
EpochFi Labs is deliberately senior-led and small. You speak to the engineer who writes the code, scopes the work, and answers for it in production. When an engagement needs additional hands, I say so before we start.
Writing, monthly
[VERIFY] Publish the first two before this section goes live. Drafts to follow if useful.
Why DeFi prototypes fail in production
The five states a demo never has to handle, and what each one costs when real positions are open.
Reviewing AI-generated Rust
Where generated concurrency and error handling quietly diverge from what the business needs.
Transaction reliability on Solana
Confirmation, retries, and the difference between submitted and settled.
Tell me what you are building.
Thirty minutes, no obligation. Bring the integration that is blocking you, the subsystem you are unsure about, or the repository you would like read. You will leave with a view on scope and risk whether or not we work together.
[VERIFY] Wire the primary button to a Cal.com or Calendly link before launch.
- What you are building, and who it is for
- Where the system is today: prototype, devnet, or live
- The problem you would most like solved first
- Any date the work is tied to
- Your team's current Rust and Solana experience
Happy to sign an NDA before reviewing anything.