Building scalable backend systems, distributed infrastructure, real-time execution pipelines, and production-grade architectures.

I build backend systems where scalability, reliability, concurrency, and operational simplicity are critical requirements.

My work spans:

• Distributed systems and event-driven architectures
• High-performance backend infrastructure
• Real-time execution and processing systems
• Blockchain and settlement infrastructure
• Healthcare interoperability systems (FHIR / HL7 / DICOM)
• Financial systems and transaction processing
• Production-grade APIs and asynchronous services

I enjoy designing systems that remain deterministic, observable, and resilient under concurrency and failure.

• Systems should remain deterministic under retries and failures
• Distributed workloads should prioritize consistency and observability
• Infrastructure should be scalable, traceable, and operationally simple
• Failures must be measurable, recoverable, and debuggable
• Performance optimizations should not compromise correctness

Production-oriented rollup and settlement architecture built in Rust

• Built a concurrent transaction sequencer using Tokio async runtime and Rayon parallel execution
• Implemented custom zero-knowledge proving pipelines with Halo2
• Designed deterministic batch processing and state transition architecture
• Developed Ethereum settlement integration using Solidity verifier contracts and Ethers-RS
• Implemented persistent state storage using RocksDB
• Built async RPC transaction ingestion services with Axum
• Added CI/CD pipelines, Dockerized infrastructure, and proof benchmarking

• Concurrent execution and async orchestration
• Distributed state transition systems
• Persistence and replay protection
• Infrastructure reliability and observability
• Cryptographic verification pipelines

→ https://github.com/samar-syd7/atlas-zk-rollup

Low-latency execution engine with deterministic order matching

• Built FIFO-based matching engine with support for partial fills and cancellations
• Designed order book architecture optimized for low-latency access
• Implemented deterministic replay-safe execution using sequence IDs
• Developed real-time streaming infrastructure for order book updates and trade execution
• Achieved sub-millisecond processing latency in local benchmarks

→ https://github.com/samar-syd7/dex-matching-engine

FHIR / HL7 / DICOM backend systems for healthcare data exchange

• Built backend systems for healthcare interoperability workflows
• Worked with HL7 messaging pipelines and DICOM imaging integrations
• Developed APIs and processing services for healthcare data exchange
• Designed scalable backend services for hospital and clinical systems

• Healthcare interoperability standards
• Event-driven healthcare workflows
• Medical data processing systems
• Backend integration architecture

Event-driven transaction ingestion and distributed risk evaluation platform

• Built Kafka-based ingestion pipelines for high-volume financial transaction streams
• Implemented distributed risk scoring and anomaly detection workflows
• Designed audit logging architecture for traceability and replayability
• Built resilient event-driven processing systems with retry handling and fault tolerance

→ https://github.com/samar-syd7/crypto-transaction-monitoring-api

Asset lifecycle and synchronization infrastructure

• Designed and deployed ERC-721 smart contracts
• Built backend services for mint → transfer → verification workflows
• Implemented blockchain event synchronization pipelines
• Handled asynchronous on-chain/off-chain consistency guarantees

→ https://github.com/samar-syd7/asset-tokenization-platform

Distributed Systems        | Backend Infrastructure
Concurrency Engineering    | Async Runtime + Parallelism
Event-Driven Architecture  | Kafka / Streaming Pipelines
Healthcare Interoperability| FHIR / HL7 / DICOM
Financial Infrastructure   | Transaction Processing
Blockchain Infrastructure  | Settlement Systems
Persistence                | PostgreSQL / RocksDB
Observability              | Metrics + Structured Logging
Infrastructure Automation  | Docker + CI/CD

Languages →
Rust · Go · TypeScript · Python · Java

Backend →
Axum · Tokio · Fastify · Django · Spring Boot · Node.js

Distributed Systems →
Kafka · Redis · Event-driven architectures

Blockchain →
Ethereum · Solidity · Halo2 · Ethers-RS · Zero-Knowledge Systems

Healthcare →
FHIR · HL7 · DICOM · PACS

Data & Persistence →
PostgreSQL · RocksDB · Relational modeling

Infrastructure →
Docker · GitHub Actions · CI/CD · Containerized services

Observability →
Prometheus · Metrics-based monitoring · Structured tracing

• Building scalable backend infrastructure and distributed execution systems
• Designing high-performance async services and event-driven architectures
• Exploring zero-knowledge systems and blockchain infrastructure
• Working on healthcare interoperability and backend integration systems
• Improving reliability, observability, and deterministic execution in distributed workloads

• Open to backend engineering, distributed systems, infrastructure, fintech, healthcare-tech, blockchain, and protocol engineering roles
• Interested in scalable systems, execution infrastructure, low-latency services, and reliability engineering

Reliable systems are deterministic, observable, scalable, and resilient under failure.