Shuvakant Patra shuvakant6623

⚙️ Systems Philosophy

Models are only as good as the infrastructure beneath them.
I build the infra.

Compiler → AST → Execution
Feature Store → DAG → Consistency
Data Pipeline → Scale → Reliability
Rust → Performance → Safety

🎯 Current Mission

Building a Compiler-Driven Feature Store from scratch.
DSL-based feature definitions
→ Parsed into AST
→ Compiled into execution plan
→ Served with zero skew

Reproducibility. Consistency.
Production-grade, always.

🔭 Primary Project — Currently Building

🏗️ Compiler-Driven Feature Store

The hardest problem in ML isn't the model. It's the features.

A production-grade feature store where features are programs, not just columns.

Architecture:

  ┌─────────────────────────────────────────────┐
  │           Feature DSL Definition            │
  │    feature("rolling_avg_7d") {              │
  │      window(7d).mean(transactions)          │
  │    }                                        │
  └────────────────────┬────────────────────────┘
                       │
                  [ PARSING ]
                       │
              ┌────────▼────────┐
              │  Abstract       │
              │  Syntax Tree    │
              └────────┬────────┘
                       │
               [ COMPILATION ]
                       │
              ┌────────▼────────┐
              │  Execution      │
              │  Plan (Rust)    │
              └────────┬────────┘
                       │
          ┌────────────▼────────────┐
          │   Online   │  Offline   │
          │  Serving   │  Training  │
          │  (no skew) │  (same fn) │
          └────────────────────────┘

What it solves:

🔴 Training-serving skew → eliminated at compiler level
🔴 Feature inconsistency → enforced via typed AST
🔴 Reproducibility gaps → execution plans are deterministic
🔴 Slow feature computation → Rust-powered engine

🚀 Built Projects

🦀 Rust Expression Engine

High-performance computation engine for ML feature pipelines

Expression parsing + evaluation from scratch
Built entirely in Rust for maximum throughput
Execution core for feature systems
Real-time ML pipeline & backend compatible

Rust Parsing Expression Trees Performance

🌊 Flood Susceptibility Model

Geospatial ML system for flood risk prediction

Predicts flood-prone regions with high accuracy
Inputs: rainfall, elevation, soil type, land cover
Pipeline: ingestion → preprocessing → evaluation
Environmental + geospatial feature engineering

Python XGBoost GeoSpatial Scikit-Learn

✈️ Flight Delay Prediction System

Time-series ML system for aviation delay forecasting

Fuses weather, historical patterns, and congestion data
Advanced time-series feature engineering
Handles multi-source data pipelines
Production-grade inference workflows

Python Time-Series Feature Engineering ML

📱 Smartphone Addiction Prediction

Behavioral ML model for digital health analytics

Detects addiction patterns from behavioral signals
Inputs: screen time, app usage, sleep cycle data
Feature extraction from temporal behavioral logs
Interpretable classification outputs

Python Behavioral ML Classification Health

🧬 Core Stack

🛰️ Systems I Love Designing

🧱 Compiler-driven feature platforms — DSL → AST → optimized execution plans in Rust.
📡 Low-latency feature serving — online/offline parity, skew-free by construction.
🧩 Typed data contracts — DAGs with lineage, schema evolution safety, and CI for data.
🚦 Observability-first — tracing, metrics, circuit breakers, chaos drills.
🕸️ Streaming + batch harmony — Kafka / Arrow / Parquet with reproducible jobs.
⚡ Performance — zero-cost abstractions, memory safety, fearless concurrency.

📊 Live Dashboards

🧠 Systems Thinking Map

┌──────────────────────────────────────────────────────────────────────┐
│                     How I Think About Problems                       │
├──────────────────────────────────────────────────────────────────────┤
│                                                                      │
│   COMPILER LENS           SYSTEMS LENS          DATA LENS            │
│   ─────────────           ────────────          ─────────            │
│   Tokenize input          Define contracts       Source + lineage    │
│   Parse to AST            Define interfaces      Schema + types      │
│   Optimize plan           Handle failures        Transform + clean   │
│   Execute safely          Scale horizontally     Serve consistently  │
│                                                                      │
│   RUST LENS               ML INFRA LENS                              │
│   ─────────               ─────────────                              │
│   Own your memory         Features = Programs                        │
│   Zero-cost abstractions  Training ≡ Serving                         │
│   Fearless concurrency    Reproducibility first                      │
│   No undefined behavior   Monitor everything                         │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘

🌱 Learning Roadmap

Now

Compiler-Driven
Feature Store
(primary project)

→

Next

Advanced MLOps
Distributed Systems
Design Patterns

→

Vision

Production ML
Infrastructure
at Scale

Provide feedback

Saved searches

Use saved searches to filter your results more quickly