PPD // Systems Architect Interface

// PROFILE

Designed for performance.
Hardened for production.

I architect shared-nothing distributed engines and low-latency data planes where every cache line, syscall, and context switch matters. Rust is my primary tool, but my real expertise is thinking in memory layouts, consensus states, and attack surfaces.

I've disclosed critical vulnerabilities in high-traffic protocols and built systems that push 220k+ ops/sec under 1ms. I bring adversarial rigor to every design — because the safest system is the one built by someone who knows how to break it.

profile.md

[identity]
name = "Partha Pratim Deka"
role = "Systems Engineer"
specialization = ["Distributed Systems", "Low-Latency", "Security"]

[stack]
language = "Rust"
runtime = "Tokio"
transport = ["QUIC", "io_uring", "eBPF"]
consensus = ["Raft", "Paxos", "BFT"]

[status]
availability = "Open for contracts"
latency = "< 1ms response"

// SKILL_MATRIX

Technical Arsenal

Low-Level Programming

Rust95%

Async / Tokio92%

Memory / SIMD / CAS88%

C++ Inline ASM SIMD Cache-aware

Distributed Systems

Consensus (Raft/Paxos)90%

Shared-Nothing Architecture94%

Lock-free Structures89%

BFT Sharding Partitioning

Networking & I/O

QUIC / Zero-copy91%

eBPF / Kernel-space84%

io_uring / epoll88%

HTTP/3 User-space TCP Protocol Design

Security Research

Memory Corruption90%

Protocol Fuzzing87%

Responsible Disclosure92%

PoC AFL++ Hardening

// SYSTEM_LOGS

Experience Records

Systems Engineering Consultant

2024 — PRESENT

> Independent Contractor (Remote)

$ Designed high-throughput distributed primitives for international clients; reduced tail latency (p99) and maximized IPC.
$ Architected fault-tolerant systems with async task-based runtimes and deterministic resource allocation in K8s/Docker.
$ Optimized hot paths by eliminating context switches and heap allocations in high-concurrency scenarios.

// DEPLOYED_SYSTEMS

Selected Projects

storage_engine.rs

Rust QUIC

Distributed Shared-Nothing Storage Engine

Core-per-thread partitioned engine eliminating global locks. Integrated QUIC for zero-copy ingestion and built lock-free primitives for inter-shard communication.

pub struct Shard {
    core_id: CoreId,
    ring: LockFreeRingBuffer,
    quic_endpoint: Endpoint,
}

impl Shard {
    pub async fn run(&mut self) -> io::Result<()> {
        pin_to_core(self.core_id)?;
        loop {
            let cmd = self.ring.pop().await;
            self.dispatch_zero_copy(cmd).await?;
        }
    }
}

220k+

OPS/SEC

<1ms

p99 LATENCY

0

GLOBAL LOCKS

vuln_research.rs

Security Fuzzing

Vulnerability Research & Protocol Analysis

Discovered and responsibly disclosed critical logic-level and memory-corruption vulnerabilities in distributed network protocols. Built multi-stage PoC exploits for networked state machines.

Memory corruption analysis

Protocol fuzzing campaigns

Responsible disclosure reports

// RESEARCH_QUEUE

Active Directions

Systems Research

eBPF observability, TLA+ formal verification, user-space networking stacks.

Optimization

NUMA-aware structures, hardware-conscious algorithms, lock-free data paths.

Distributed Theory

Byzantine Fault Tolerance, consensus protocols, sharding algorithms.

// ESTABLISH_CONNECTION

Open a Channel

contact@ppd.sys

PPD Systems Interface v2.6.0
Available commands: help, email, linkedin, upwork, hackerone, hire, clear

root@ppd:~$ _

PARTHA PRATIM DEKA

Designed for performance. Hardened for production.