Frank Lin

Lead backend engineering for Fireblocks digital asset platform, architecting production grade Rust components that process billions in daily transfers with zero critical incidents.
Designed a horizontally scalable validator node architecture using Terraform managed infrastructure, supporting 40% higher transaction throughput while cutting infrastructure costs by 25% across multiple global geographic regions.
Spearheaded migration of legacy C++ codebase to Rust, improving memory safety and eliminating use after free vulnerabilities across critical consensus and networking modules.
Implemented a custom P2P networking layer using libp2p and gRPC over TCP/IP, reducing peer discovery latency by 35% and enabling reliable communication across 5000 node clusters.
Built a deterministic state machine and transaction pool executor in Rust, cutting block production time from 800 milliseconds to 200 milliseconds while preserving consensus guarantees.
Created a fuzz testing harness with property based tests that uncovered 15+ edge case bugs in consensus and state synchronization logic before production release.
Mentored six backend engineers on Rust ownership semantics, concurrency patterns, and low level systems programming topics covering compilers, kernels, and machine simulators through weekly design reviews.
Architected a sharded storage layer using RocksDB with custom compression, reducing storage footprint by 50% while maintaining sub millisecond read latency under heavy concurrent load.
Led cross functional collaboration with product managers, QA, and DevOps to deliver quarterly releases of core backend services with comprehensive integration testing while meeting a 99.99% availability SLA.
Designed a Byzantine fault tolerant consensus protocol layer in Rust, validated through 200+ chaos engineering experiments and comprehensive formal verification with TLA+ specifications.
Implemented secure multi party computation primitives for transaction signing, reducing signing latency from 2 seconds to 300 milliseconds while preserving full audit trail.
Redesigned the block propagation engine to reduce network bandwidth consumption by 60% through compact block relays and novel erasure coding techniques while improving propagation reliability.
Established a continuous deployment pipeline on AWS with automated staging and canary releases, accelerating feature delivery from biweekly to daily deployments without increased incident rates.
Drove architecture review and RFC processes for production consensus layer changes, ensuring backward compatibility and zero downtime upgrades across a rotating validator set.
Optimized the cross shard communication protocol using asynchronous message passing and batching, reducing transaction finality time by 45% across a distributed validator set.
Collaborated with security engineering to harden the mempool against spam and DoS attacks, implementing fee market adjustments that reduced rejected transactions by 70%.
Instrumented distributed tracing and performance monitoring across backend services, identifying bottlenecks that led to a 30% reduction in p99 latency across the entire platform.
Evaluated and integrated Zig modules for high performance cryptographic hashing, achieving 20% faster hash computation compared to existing Rust implementations and contributing results back to open source.

Led migration of the exchange matching engine from Python to Rust, achieving a 10x improvement in order processing throughput and reducing trade execution latency to 50 microseconds.
Architected a WebSocket API gateway in Rust handling 1 million concurrent connections, enabling real time market data streaming for institutional clients across global regions.
Designed and implemented rate limiting and load balancing middleware protecting backend APIs from abuse, reducing DDoS related downtime incidents by 90% across trading infrastructure.
Collaborated with product and trading teams to build a margin trading system with isolated risk management, supporting 30% more trading pairs without additional infrastructure costs.
Improved internal data replication using change data capture, reducing synchronization lag between trading engines and reporting databases from minutes to sub second level.
Mentored junior engineers on systems design and Rust best practices, reviewing over 200 pull requests and driving adoption of coding standards across the backend team.
Led a cross team reliability initiative using chaos engineering simulations, resulting in a 40% reduction in mean time to recovery during live outage drills and production incidents.
Implemented a lock free concurrent order book data structure in Rust, supporting 2 million active order updates per second during peak trading load with rigorous performance benchmarking.
Redesigned the settlement processing service with idempotent retry logic and transactional outbox patterns, reducing settlement failures by 80% and audit resolution time by 50%.
Built a real time transaction monitoring system that flagged suspicious activity within 200 milliseconds, enabling compliance teams to respond faster to potential market manipulation.
Optimized PostgreSQL sharding for user accounts and trade history, scaling the platform to support 15 million users with consistent sub second query response times.
Contributed to open source Rust projects maintained by the exchange, including upstream fixes to tracing and metrics libraries adopted by the broader Bitcoin and Ethereum ecosystem.
Designed a high availability failover mechanism for critical trading services, reducing recovery time objective from 5 minutes to 30 seconds and eliminating single points of failure.
Spearheaded evaluation and adoption of Zig for low level system utilities, achieving 35% lower memory usage in networking hot paths while maintaining interoperability with existing Rust services.

Designed and implemented a Blockchain node service in Rust for game asset ownership validation, reducing asset verification latency from 3 seconds to 400 milliseconds.
Built a scalable event ingestion pipeline using Kafka and gRPC, processing 500 million daily game events with 99.99% delivery reliability to analytics and in game systems.
Led a small team of four engineers to develop a marketplace backend service in Go, supporting 10000 concurrent users and 50% growth in digital asset transactions.
Collaborated with game designers and product managers to integrate Solidity based NFT minting and trading functionality into existing backend infrastructure, launching two successful in game economies.
Improved system reliability by implementing comprehensive observability dashboards and automated alerting, reducing mean time to detection for production issues from 30 minutes to 5 minutes.
Refactored a monolithic Python backend into Docker packaged microservices deployed on Kubernetes, improving deployment frequency from monthly to weekly while reducing cloud costs by 30%.
Implemented a caching layer using Redis for game asset metadata, reducing database load by 60% and improving API response times by 35% during peak gaming events.
Actively participated in open source blockchain gaming standards discussions and contributed reference implementations for asset interoperability within the Ethereum and ERC1155 ecosystem that gained community adoption.

Developed embedded firmware for IoT devices using C and C++ on ARM Cortex microcontrollers, implementing real time sensor data processing and communication protocols.
Built a cross platform data synchronization engine for a client application, reducing sync time from 4 minutes to 15 seconds and supporting offline operations.
Collaborated with hardware engineers to optimize low level memory management and interrupt handling, achieving 40% reduction in power consumption for battery operated devices.
Designed a custom serialization protocol in C++ for high throughput data transfer between embedded devices and cloud backends, handling 5000 messages per second.
Led technical design reviews for firmware architecture and wrote comprehensive documentation, enabling seamless knowledge transfer and 30% faster onboarding for incoming engineering hires.

Developed low level sensor firmware in C for a wearable fitness device, processing accelerometer and heart rate data at 100 hertz with 95% accuracy.
Implemented a Bluetooth Low Energy communication stack that synchronized device data with mobile applications, cutting sync failures by 60% across Android and iOS platforms.
Collaborated with data scientists to build a sleep tracking algorithm pipeline, improving sleep stage classification accuracy by 25% through signal processing and feature engineering.
Improved battery life of the wearable device through low level power management optimizations in firmware, extending usage from 3 days to 5 days on a single charge.
Participated in code reviews and cross functional sprint planning with mobile, hardware, and QA teams, contributing to the delivery of two major firmware releases per year.