Abhishek Thulasi

Implementation Scope

Designed the foundational architecture for a cross-platform multiplayer ecosystem, balancing long-term maintainability with rapid development cycles. I architected a cross-platform game launcher utilizing Flutter and Rust-based binary patching, while simultaneously defining engineering standards for the Unity client—introducing .asmdef compiler fences, dependency injection, and strict garbage collection optimizations. Beyond core architecture, I pitched an immersive, "scrollytelling"-driven web portal leveraging Lenis scroll and mentored junior developers to unblock parallel workflows. The backend relies on a unified monorepo that strictly separates stateless logic from stateful persistent coordination, orchestrating observability via OpenTelemetry for distributed tracing.

Backend & Data

Client & Frontend

Infrastructure & Ops

Implementation Scope

Engineered a custom passwordless Identity Provider using Golang and Svelte. The onboarding flow utilizes Zepto for initial email OTP verification. Infrastructure protection includes rate limiting, email-bombing prevention, and OTP retry locking. Valkey handles this ephemeral state, providing sub-millisecond validation for the 5-minute OTP lifecycle. Upon successful validation, user profiles persist to AWS Aurora PostgreSQL, and the system prompts the user to register a device Passkey (FIDO2/WebAuthn). This ensures subsequent logins are biometric authentications, secured via PASETO session tokens.

Protocols

Infrastructure

The Problem

Distributing multi-gigabyte application updates results in high CDN bandwidth costs for bootstrapped startups.

The Solution

To prove the ROI of binary diffing and secure R&D buy-in, I engineered a Rust CLI tool that reduced update payloads by 98% (128MB to 1.95MB), cutting projected AWS CDN egress costs from $11,500 to $175 per million downloads. The core engine utilizes memory-mapped I/O (`memmap2`), the `bsdiff` algorithm for delta generation, and `zstd` for compression. State integrity is strictly enforced via `blake3` hashes embedded directly into the patch headers. Beyond single files, the tool features a custom directory patching pipeline that traverses file trees to generate a unified manifest of modified, created, and deleted assets. A key finding from this R&D phase was a scaling bottleneck: `bsdiff` suffix sorting requires holding both the old and new files in memory simultaneously. Triggering OOM thresholds on large payloads proved that production implementations must pivot to sliding-window algorithms like Xdelta or HDiffPatch to maintain a flat memory footprint.

Strategic Goal

Project Phase

Core Libraries

The Problem

Standard Salesforce integrations with custom logic often require hardcoding a dedicated REST endpoint for every new data object. As an enterprise scales, this creates technical debt and rigid codebases.

The Solution

Engineered a dynamic data gateway capable of upserting any SObject—and inserting nested child records—in a single bulkified transaction. To ensure the core REST controller remains untouched as business requirements evolve, the system uses a custom metadata-driven Factory pattern. This architecture allows developers to inject object-specific logic via "Before" and "After" Apex interfaces. The framework natively handles dynamic JSON type-casting and enforces Field-Level Security (FLS) across all payloads.

Business Impact

Architecture

Capabilities

The Problem

Cloud storage enforces recurring operational costs and introduces privacy trade-offs, while personal devices have underutilized storage capacities.

The Solution

Built a prototype for a local-first sync engine designed to bypass the cloud. Driven by a Rust core with a Flutter UI, the system targeted two primary modes: a two-way active directory sync between trusted devices, and a one-way encrypted vault. Development was paused after determining the sync feature required a fundamentally different cryptographic architecture, but the prototype successfully validated the core device-to-device communication pipeline over local Wi-Fi.

Architecture

The Problem

Modern libraries like Socket.io abstract away the complexities of TCP persistence, connection drops, and memory management. This project was built to explore the raw engineering behind stateful network connections.

The Solution

Engineered a full-duplex chat system from the ground up without managed real-time wrappers. The backend is written in Golang, utilizing a custom Hub-and-Client architecture that leverages goroutines and channels to multiplex raw WebSocket streams safely across concurrent users. The frontend utilizes Svelte to manually manage the socket lifecycle and state stores, bridging real-time events with IndexedDB for local caching and SurrealDB for persistent relational storage.

Concurrency Model

Data Layer