Shees — Portfolio | Software Engineer & Graphics Developer

Projects & Experience

Automatic Job Application and Tracking System

Intelligent Job Application Automator

An autonomous web-agent framework designed to automate the complete lifecycle of online job applications across dynamic corporate portals. The core engine is built in Python, uses Playwright for browser control, SQLite for persistent storage, and an LLM for cognitive decision-making.

Tags: AI, Automation, Backend

Automatic Job Application and Tracking System

Autonomous web-agent for automated job applications. Uses Playwright and Gemini to traverse portals, upload files, and submit forms in under 5s on cached domains.

Execution Telemetry

// 10X SPEEDUP OVER MANUAL OR STANDARD AUTOMATION //

Distributed FSM

Four concurrent workers (sourcing, redirection, classification, execution) communicate via event bus. Vector RAG aligns questionnaire prompts with dossiers without exposing raw data.

WORKER 01 SOURCING Streams listings from external boards into a centralized queue. Deduplicates canonical URLs in real-time.

WORKER 02 REDIRECTION Stealth service maps unstructured external links to canonical endpoints. Cascading locator strategies bypass bot detection.

WORKER 03 CLASSIFICATION Vector RAG aligns questionnaire prompts with structured dossiers. Semantic mapping bypasses fragile RPA selectors.

WORKER 04 EXECUTION Multi-strategy file uploads, form fills, OAuth routing. Captures pre/post/crash screenshots per selector action.

Cascading Locators

Progressively resilient selector chain: ARIA roles → text match → CSS cascade → shadow DOM piercing.

ARIA ROLE RESOLUTION

Maps role="button" and role="link" elements to application form entry points using Playwright's built-in role locators.

TEXT & VISIBILITY MATCH

Fallback to Playwright text locators with visibility checks. Filters hidden or off-screen elements using bounding-box heuristics.

CSS SELECTOR CASCADE

Progressive CSS selector chain: data attributes → class names → ID references. Each step strips unstable styling classes to target semantic structure.

SHADOW DOM PIERCING

Recursive shadow-root traversal for web-component-heavy SPAs. Enters nested shadow boundaries to reach deeply embedded form controls.

// CASCADING STRATEGY — PROGRESSIVELY RESILIENT LOCATOR CHAIN //

ARIA Snapshot → YAML

Playwright ARIA snapshot engine extracts viewport layout to YAML. Strips styling/scripts to map form controls to the cognitive pipeline.

Debugging & Screenshots

Three-tier logging captures pre-action, post-action, and crash-state screenshots for every selector and click.

TIER 01 PRE-ACTION

Captures viewport state before each interaction. Validates that the target element exists, is visible, and enabled. Logs page URL and active frame context.

TIER 02 POST-ACTION

Captures viewport after simulated click or input. Compares DOM state delta — detected mutations, navigation events, and form-field population results.

TIER 03 CRASH-STATE

Emergency capture on timeout, navigation failure, or selector error. Logs full stack trace, current URL, DOM snapshot, and all prior state transitions.

Site Guide Caching

Records form-field mappings to SQLite on first visit. Cached hostnames bypass the AI pipeline entirely — sub-5s execution.

FIRST VISIT — AI PIPELINE ACTIVE LLM analyses page structure, RAG maps form fields to dossier. Site guide records successful mappings to local SQLite DB.

~50s

CACHED HOST — DB LOOKUP AI pipeline bypassed. Site guide replay loads pre-recorded selector chains, iframe contexts, and field mappings from database.

<5s

Deduplication & Iframe Tracking

Resolves query-param variants to canonical URLs. Proactively tracks the dominant iframe in multi-frame SPAs.

URL DEDUPLICATION

Resolves query-param variants, tracking fragments, and redirect chains into a single canonical entry per listing.

/jobs/123?ref=linkedin → /jobs/123

DOMINANT-IFRAME TRACKING

Proactively identifies the primary content frame in multi-iframe SPAs. Locks navigation to the active form context.

Frame depth: 3 | Active: #application-form → Content locked

Core EnginePython, Playwright Async API

Cognitive PipelineGemini Flash & Pro, Vector RAG

Data LayerSQLite, BeautifulSoup4

Layout ParsingARIA Snapshot Engine, YAML Generator

Auth & SecurityOAuth Routing, Stealth Redirection

DebuggingThree-Tier Logging, Pre/Post/Crash Screenshots

[ Screenshots and Media will be added soon ]
Request

E2E Encrypted Chat Application

Secure Communication

A secure, peer-to-peer, disposable communication application built entirely in Java. Utilizes WebSocket-based signaling and native WebRTC data channels to deliver end-to-end encrypted messaging.

Tags: CyberSec, Backend, Frontend

E2E Encrypted Chat Application

Peer-to-peer encrypted chat with WebRTC data channels. Multi-room tabbed UI with lobby discovery, private rooms, and file transfers.

PROPAGATION

< 100ms

Sub-100ms message delivery via native WebRTC data channels.

RETENTION

ZERO

Guarantees absolute zero server-side data retention.

Signaling

WebSocket signaling server handles SDP/ICE handshake, then drops off once the P2P tunnel is established.

P2P TUNNEL ESTABLISHED All subsequent data flows directly between peers.

Cryptography

PBKDF2 key derivation with AES-256-GCM symmetric encryption. Room name used as salt to prevent rainbow table attacks.

Key DerivationPBKDF2WithHmacSHA256

Message CipherAES-256-GCM

Salt MaterialTarget Room Name

Iterations65,536

Rendering & Diagnostics

Java Swing UI with glassmorphic tabs, live connection logs, and avatar fallback to initials.

Graphics EngineAWT Graphics2D

Layout ManagersGridBagLayout, CardLayout

PerformanceLow-Overhead Streaming I/O

[ Screenshots and Media will be added soon ]
Request

Atmospheric Scene

Stylized world

A fully stylized atmospheric 3D scene built with Three.js, featuring volumetric fog, dynamic lighting, and custom GLSL shaders for weather effects.

Tags: Three.js, GLSL, WebGL, Post-processing

Atmospheric Scene

A fully stylized atmospheric 3D scene built with Three.js, featuring volumetric fog, dynamic lighting, and custom GLSL shaders for weather effects.

E-commerce Operations & ERP Platform

Full-Stack Developer — Jan–Apr 2026

Engineered a full-stack ERP & Business Management system (React/Supabase) to centralize international orders, inventory, and CRM, scaling infrastructure leading to a 40% increase in daily order volume.

Tags: React, Supabase, PostgreSQL, TypeScript, Stripe, PayPal, ERP

E-commerce Operations & ERP Platform

Engagement Timeline

DISCOVERY

Requirements

HANDOVER

Documentation

Business Impact

DAILY ORDER VOLUME

X +40%

Baseline volume +40% uplift

ADMIN TIME SAVED

Manual 25+ hrs/wk

Manual accounting, reconciliation, and order processing eliminated.

AUTOMATED ERROR-FREE

Multi-Channel Payment Engine

Automated Stripe/PayPal fee calculations with reverse-costing that guarantees net profit margins across currencies and tax regions.

Processing Fee 2.9% + $0.30

Intl. Card +1.5% FX fee

Currency Conversion +1% spread

TOTAL EST. DEDUCTION: 4.9% + $0.30

Processing Fee 3.49% + $0.49

Intl. Transaction +1.99% FX fee

Cross-border +1.5% fixed

TOTAL EST. DEDUCTION: 6.98% + $0.49

Margin Protection Cascade

Each fee layer (processor, FX, tax, spread) is subtracted from the gross price to preserve the target net profit margin.

NET PROFIT TARGET

Guaranteed margin per unit

Processor rate (3.5% Stripe)

+$3.50

Local GST on gateway (18%)

+8.99

Exchange rate spread (1.2%)

+.50

GROSS FOREIGN PRICE

Price charged to customer

// EACH FEE LAYER IS A STEPWISE INCREMENT — PROFIT REMAINS INVARIANT //

Audit Logging

Custom audit tables record every alteration. Payment-gated state machine prevents progression to MFG/shipping without payment.

TIMESTAMP EVENT ENTITY STATE AUDIT HASH

2026-03-15 09:23 order.created ORD-4281 PENDING a3f2...b8

2026-03-15 09:45 payment.received ORD-4281 PAID b7d4...e1

2026-03-15 10:02 status.transition ORD-4281 MFG f9c1...a4

2026-03-18 14:15 shipment.created ORD-4281 SHIPPED e2b7...d3

// EVERY TRANSACTIONAL ALTERATION — TIMESTAMPED, HASHED, IMMUTABLE //

Order Lifecycle

MANUFACTURING

gate: must be PAID

SHIPPED

Fulfillment active

Liquid Time Scheduler

Priority-queue slots tasks into calendar gaps over a rolling 30-day window with configurable session limits and recovery buffers.

PRIORITY QUEUE

Deadline-critical

Standard task

Fixed commitment

FIXED

Team standup (daily)

TASK #104

Order #4281 — 4hrs

TASK #108

Catalog sync — 2hrs

// ROLLING 30-DAY WINDOW — PRIORITY-SORTED QUEUE FITS INTO CALENDAR GAPS //

Kanban Pipeline

React-admin Kanban with payment badges, due-date alerts, and state transitions.

Technology Stack

PlatformReact (TypeScript), Vite, TailwindCSS, MUI

Backend & DatabaseSupabase, PostgreSQL, PL/pgSQL Triggers

PaymentsStripe API, PayPal Commerce, ExchangeRate-API

Financial EngineReverse-Calculation, Multi-Tier Costing, Regional Tax

Security & AuditPostgreSQL RLS, Search Path Isolation, Audit Ledger

[ Screenshots and Media will be added soon ]
Request

Client-Side Security Analysis Engine

Automated SAST Scanner

An automated static application security testing (SAST) engine that detects exposed secrets, PII, and insecure endpoints in client-side JavaScript through real-time network interception and AST analysis.

Tags: CyberSec, Backend, AI

Client-Side Security Analysis Engine

SAST engine that detects exposed secrets, PII, and insecure endpoints in client-side JS using Playwright interception and Esprima AST analysis.

Scan Pipeline

REAL-TIME CRAWL & INTERCEPT

Headless browser executes live network interception. Captures lazy-loaded assets, dynamic imports, and inline scripts in real time.

Playwright

AST CONSTRUCTION & WALK

Esprima

ENTROPY SCAN & DETECTION

Shannon Entropy measures string randomness. Classifies high-entropy crypto keys vs low-entropy placeholders. Regex fallback for modern syntax.

Entropy / Regex

LLM BATCH VALIDATION

High-threat scripts batched into XML-wrapped consolidated prompts. Async semaphores manage concurrent API calls. Thread-pool prevents blocking.

LLM API

REPORT GENERATION

Categorized HTML report highlights credential leaks, PII exposures, and suspicious headers. CSV export for downstream ingestion.

Jinja2 / CSV

AST Tree-Walk

Headless browser intercepts network traffic, Esprima builds an AST, then recursive tree-walk evaluates declarations, properties, and comments.

SCRIPT NODE [ROOT] Entry point — recursive walk begins here

VAR_DECLARATION

const API_KEY = "..."

FUNCTION_DECL

function fetchData()

LITERAL [STRING]

⟶ ENTROPY EVALUATION

COMMENT_BLOCK

// TODO: remove key

// RECURSIVE DFS TRAVERSAL — VISITS EVERY NODE IN SCOPE CHAIN //

Shannon Entropy Detection

Entropy check distinguishes crypto keys from placeholders. Regex fallback handles mixed dialects, plus Chromium-based PII pattern matching.

LOW ENTROPY ← PLACEHOLDER

HIGH ENTROPY → CRYPTO KEY

"placeholder"

"sk-8a9b3c2d1e0f..."

// THRESHOLD: H(X) ≥ 4.5 BITS PER CHARACTER → TRIGGERED FOR REVIEW //

Multi-Stage Filtering

Regex heuristics filter 70% of scripts early. High-threat scripts batched into XML-wrapped consolidated prompts with async semaphore concurrency control.

ALL DETECTED SCRIPTS 100%

STAGE 01 — REGEX HEURISTICS Quick-pass filter discards low-risk assets early ~70% REMOVED

STAGE 02 — LLM BATCH VALIDATION High-threat scripts batched into XML-wrapped prompts ~20% QUEUED

STAGE 03 — CONFIRMED THREATS Credential leaks, PII exposures, suspicious headers ~10% REPORTED

Concurrency

ASYNC SEMAPHORE

API Requests → Bounded Pool

Manages concurrent LLM API requests through a controlled semaphore. Prevents rate-limit saturation while maximizing throughput during batch validation.

THREAD-POOL OFFLOAD

CPU Work → Event Loop

Heavy parsing and entropy calculations offloaded to thread pool. Prevents event-loop blocking, maintaining responsiveness during large-scale scans.

Reporting

HTML report with categorized findings (credentials, PII, headers). CSV export and beautified source code artifacts for triage.

HTML REPORT

Credential leaks, PII exposures, suspicious HTTP headers, and beautified debug artifacts.

CSV EXPORT

Structured diagnostic logs, Jinja2 templated for downstream DB ingestion.

Technology Stack

Core & AST ParsingPython 3, Esprima, Playwright

Server & APIUvicorn, FastAPI, WebSocket

AI & DetectionLLM API, Shannon Entropy, Regex Engine

Data & DeliveryYAML Config, Jinja2, CSV Export

[ Screenshots and Media will be added soon ]
Request

Custom TrueType Font Parsing & Vectorization Engine

Binary TTF Parsing & Bézier Vectorization

A custom TrueType Font (TTF) parsing and vectorization engine built from scratch in C++ with OpenGL. Directly reads raw binary font files without external typography libraries, decoding multi-byte UTF-8 text and rendering precise glyph geometry through quadratic Bézier interpolation.

Tags: Graphics, Backend

Custom TrueType Font Parsing & Vectorization Engine

Custom C++ TTF parser decoding raw binary font tables, extracting glyph contours, and rendering vectorized type via quadratic Bézier interpolation — zero external typography libraries.

Glyph Rendering Roadmap

RAW BINARY

0x00 01 50 4F 53 01 02

0x05 06 07 08 09 10 11

0x12 13 14 15 16 17 18

BYTE-BY-BYTE TTF READ

TABLE DIRECTORY

cmap glyf loca head hmtx

12 TABLE RECORDS MAPPED

GLYPH EXTRACTION ON/OFF-CURVE POINTS

BÉZIER INTERP QUADRATIC BÉZIER

RASTER OUTPUT OPENGL FILLED RENDER

OUTPUT

A U+0041 · DYNAMIC SCALING

Debug Visualization

On-curve (cyan), off-curve (orange), and dynamically implied midpoints (gold) plotted against a scaled grid via ImGui overlay — validating curve interpolation accuracy.

GLYPH — A (U+0041)

8 on-curve · 3 off-curve · 2 implied

DIAGNOSTIC OVERLAY

Total Points 13

On-Curve 8

Off-Curve 3

Implied 2

Contours 3

Technology Stack

Core EngineC++20, Direct Binary I/O

Graphics APIOpenGL 4.6, Custom Shader Pipeline

Window SystemGLFW 3.4

Debug UIImGui, Custom Debug Visualizer

Text EncodingMulti-Byte UTF-8 Decoder

Font ParsingZero External Libraries — Pure C++

Repository Discovery & Timeline Reconstruction

Contribution Graph Optimizer

An automated local repository discovery and timeline reconstruction engine that discovers local git repositories, extracts commit histories, and intelligently redistributes commit timestamps for optimal contribution patterns.

Tags: Backend, AI

Repository Discovery & Timeline Reconstruction

Discovers local git repos and redistributes commit timestamps for optimal contribution graph patterns. Dashboard or CLI interface.

Temporal Scattering Algorithm

Deterministic RNG distributes commits across the timeline with weekend probabilities, working hours, and vacation gap constraints. Forward-sweep preserves original ordering.

BEFORE — SPORADIC HISTORY Clustered bursts

AFTER — SCATTERED High evenness score

// DETERMINISTIC RNG — MD5-HASHED COMMIT DATA SEEDS PSEUDORANDOM TIMESTAMPS //

Scattering Constraints

WEEKEND PROBABILITY

Configurable Sat/Sun commit likelihood weight.

WORKING HOURS

9AM–5PM window to mimic realistic commit timing.

VACATION GAPS

Configurable blackout periods to skip date ranges.

Dashboard Visual Diagnostics

Interactive scatter chart and heatmap compare original vs planned timelines. Live JSONL telemetry streams from backend subprocesses.

COMMIT SCATTER — HOUR vs DATE

Original Planned

COMMIT INTENSITY — HEATMAP

Low High

Performance Engineering

Extraction cache indexed by HEAD hash prevents redundant parses. Compressed commit datasets minimize LLM token costs. Temp file I/O avoids Windows shell quoting crashes.

EXTRACTION CACHE

Indexes past scans using HEAD hashes to prevent redundant repository parses.

DIRECTORY SWEEPS

Lightweight os.scandir with exclusion rules bypasses unnecessary filesystem checks.

TOKEN OPTIMIZATION

Commit datasets compressed before LLM processing to minimize OpenRouter token costs.

WINDOWS SAFETY

Serialization to temp disk files prevents subprocess quoting crashes on Windows.

JSONL TELEMETRY {"event": "scan.complete", "repos": 12, "commits": 340} LIVE

Technology Stack

Core APIsOpenRouter, Git CLI, GitPython

UI & DiagnosticsChart.js, HTML5, Vanilla JS, JSONL Streams

Performancegit-filter-repo, MD5 RNG, Cache Index, Temp File I/O

[ Screenshots and Media will be added soon ]
Request

JudgeMentor — Project Evaluation Framework

Multi-Subsystem Assessment Engine

Automated evaluation framework for software engineering projects. Ingests repositories, runs graph-theoretic analysis via Syknap, packs relevant slices into token budgets, generates reports via LLM summarization, and exports multi-page PDFs.

Tags: AI, Backend, Full Stack

JudgeMentor — Project Evaluation Framework

JudgeMentor is a multi-subsystem evaluation framework that automates assessment of software engineering projects, replacing subjective manual grading with quantitative analysis across four subsystems: a PowerShell ingestion client, a FastAPI orchestration backend, the Syknap graph-theoretic evaluation engine, and a single-page application frontend. Repositories are ingested with a one-liner PowerShell command, redacted for sensitive information, compressed, and transmitted to the backend. The frontend renders live pipeline progress, interactive dashboards, and exportable reports without requiring a page reload.

Pipeline

Score Dashboard

87 / 100

AGGREGATE SCORE — PASS

Weighted across 6 normalized dimensions with rubric-specific coefficients

VERDICT: PASS

// SIX DIMENSIONS — NORMALIZED & RUBRIC-WEIGHTED //

Token Packing Strategies

Four packing strategies selected by a QueryIntent classifier. Greedy knapsack packs the highest-value code slices within a token budget. Under-utilized budgets auto-expand to maximize context.

RELEVANCE-FIRST

Top-K scoring nodes packaged first by CWS rank, ensuring the most structurally important code fits within budget.

DEPENDENCY-FIRST

Walks transitive closure of program dependencies to include caller-callee chains as complete behavioral units.

BREADTH-FIRST

Wide module coverage with shallow dependency depth, prioritizing surface-area understanding over deep analysis.

ADAPTIVE

QueryIntent classifier dynamically selects mixed strategies based on natural language query analysis.

LLM Summarization Pipeline

Four-tier summarization: function → module → feature → project. Instructor extracts structured Pydantic output. LiteLLM routes across providers with configurable batch sizes. Content-addressable SHA-256 caching prevents redundant summarization across sessions.

FUNCTION

Per-method summary

MODULE

Per-file aggregation

FEATURE

Louvain cluster synthesis

PROJECT

Top-level report

Vector Storage

LanceDB manages five vector tables for function slices, module summaries, feature summaries, and project summaries — all indexed with Sentence-Transformer embeddings for semantic search. SHA-256 content-addressable caching eliminates redundant computations across sessions.

Frontend SPA

Six-page SPA built with vanilla JavaScript and Vite 6. Includes a landing page with PowerShell one-liner animation, plugin selection toggles, animated pipeline processing, score dashboard with count-up cards and staggered bar fills, and a full off-screen layout captured via html2canvas into a multi-page jsPDF with configurable format and page style.

CWS ALGORITHM

6 normalized dimensions → single relevance score. Configurable budget curves: linear, exponential, stepped. Maps scores to LLM token allocations.

SHA-256 CACHING

Content-addressable storage caches graphs, summaries, and vector embeddings across sessions. Eliminates redundant re-computation on repeat analyses.

MCP SERVER

Model Context Protocol via stdio + SSE transports. All Syknap tools exposed for direct IDE integration with Claude Desktop, Cursor, and MCP-compatible agents.

ELASTIC BUDGET

Under-utilized token budgets auto-expand dynamically. Greedy knapsack packs the highest-value code slices within the available budget.

PII REDACTION

Regex-based PII masking and prompt injection sanitization. Respects .syknapignore patterns and .gitignore rules during ingestion.

PDF EXPORT

Off-screen layout built in-memory spanning cover, plugin scores, and feedback pages. Captured via html2canvas and stitched into multi-page jsPDF.

Deployment

Docker Compose orchestrates three services: the FastAPI backend, the Syknap MCP daemon, and an ngrok tunnel. A shared Docker volume carries uploaded repositories from the backend to the evaluation engine. The frontend is built with Vite and deployed on Vercel.

Technology Stack

EngineNetworkX, Tree-sitter, Joern CPG, CWS

LLM & VectorLiteLLM, Instructor, LanceDB, Sentence-Transformer

BackendFastAPI, Pydantic, Docker Compose (3 services)

FrontendVanilla JS, Vite 6, html2canvas, jsPDF

ProtocolMCP (Model Context Protocol), SSE Transport

CLITyper (7 commands: info/index/index-dir/metrics/search/pack/serve)

[ Screenshots and Media will be added soon ]
Request

Multi-Tenant ERP, CRM & OMS Platform - Full Stack

Enterprise Resource Planning

A high-performance, multi-tenant enterprise resource planning (ERP) and order management system (OMS) engineered with React Admin, Vite, and Supabase managing complex customer pipelines and financial analytics.

Tags: Frontend, Backend

Multi-Tenant ERP, CRM & OMS Platform - Full Stack

Multi-tenant ERP/OMS with Kanban, calendar scheduling, pricing matrices, review portals, and email automations. Sub-100ms response targets.

System Architecture

TIER 01 — PRESENTATION LAYER

React Admin shell with MUI components, Kanban boards, FullCalendar widgets, and drag-and-drop interfaces. Vite dev server with TypeScript strict mode.

React / Vite / MUI

TIER 02 — API & MIDDLEWARE

Supabase real-time subscriptions, Row-Level Security enforcement, Node.js edge functions. Handles auth, file upload, and ExchangeRate-API proxying.

Supabase / Node

TIER 03 — PERSISTENCE LAYER

PostgreSQL with PL/pgSQL functions, triggers, and audit tables. Index-optimized schemas with RLS policies for multi-tenant isolation and data security.

PostgreSQL / PL/pgSQL

Performance Targets

READ LATENCY

<100ms response targets for dynamic drag-and-drop workflows.

TENANT ISOLATION

PostgreSQL Row-Level Security (RLS) policies isolate workspace data.

CACHE HIT RATE

Twelve-hour local storage FX cache mitigates gateway call load.

Reverse-Calculation Engine

Multi-tier costing equation guarantees net profit margins across currencies by factoring processor rates, FX fees, GST, and exchange spreads.

TARGET

Net Profit Margin 00 / unit

+3.5% Processor Transaction Rate 03.50

+$2.00 Currency FX Fee 05.50

+18% GST Local Tax on Gateway 24.49

+1.2% Exchange Rate Spread 25.99

FINAL FOREIGN PRICE

25.99 / unit charged

PROFIT: 00.00

OVERHEAD: $25.99

// MULTI-TIER EQUATION: PRICE = PROFIT / (1 − Σ RATES) //

Liquid Time Scheduler

Priority-sorted queue slots tasks into available time gaps over a rolling 30-day window with configurable session limits and recovery buffers.

PRIORITY QUEUE

Deadline-critical

Standard task

Fixed commitment

FIXED

Team standup (daily)

TASK #104

Order #4281 — 4hrs

TASK #108

Catalog sync — 2hrs

// ROLLING 30-DAY WINDOW — PRIORITY-SORTED QUEUE FITS INTO CALENDAR GAPS //

Kanban Pipeline

React-admin Kanban with payment badges, due-date alerts, and MFG state transitions.

Database Security

Postgres RLS, search path hardening, automated triggers for SKU validation, variant generation, audit logging, and payment-gated state transitions.

All tables protected by RLS policies. Subquery-based InitPlan scalar checks verify tenant context on every read/write operation.

All functions and triggers bound to public schema with explicit search_path — neutralizing injection vectors.

SKU uniqueness validation, base variant generation, audit logging. State transitions enforce payment constraints before manufacturing/shipping.

Custom audit tables record every transactional alteration. Absolute reproducibility and complete change-logging across all entities.

Performance

Composite B-tree indexes, RLS optimization, and 12-hour FX cache reduce latency.

INDEX STRATEGY

Composite B-tree indexes minimize read-write latency.

FX CACHING

12-hour local storage caching reduces ExchangeRate-API hits.

RLS OPTIMIZATION

InitPlan scalar subqueries optimize per-tenant row isolation.

Technology Stack

Core BackendSupabase, PostgreSQL, Node.js

UI FrameworkReact Admin, MUI, TailwindCSS, Vite

Interactive ComponentsFullCalendar, @hello-pangea/dnd, Lucide

Financial EngineReverse-Calculation, ExchangeRate-API

Security LayerPostgreSQL RLS, Search Path Isolation

[ Screenshots and Media will be added soon ]
Request

Realtime Lighting

Dynamic mood

Real-time global illumination system with dynamic shadow mapping and emissive material blending for mood-driven environmental storytelling.

Tags: Three.js, Shadow Mapping, PBR, WebGPU

Realtime Lighting

Real-time global illumination system with dynamic shadow mapping and emissive material blending for mood-driven environmental storytelling.

Secure Federated Learning

Homomorphic Encryption & Privacy

A privacy-preserving federated learning platform that enables collaborative machine learning across decentralized datasets without exposing raw user data.

Tags: CyberSec, AI, Backend

Secure Federated Learning

Privacy-preserving federated learning with homomorphic encryption and differential privacy. Real-time animated dashboard for visualization.

HEALTHCARE DIAGNOSTICS

> 93% ACCURACY

Test accuracy on encrypted healthcare datasets with CKKS active.

NASA PROGNOSTICS

0.08 RMSE

Root Mean Square Error on battery prognostics testing.

Training Round

Five-phase state machine: idle → selection → local training → encryption → completion.

LOCAL TRAINING
PRIVATE DATA

CKKS Encryption Pipeline

Clients encrypt weight tensors using CKKS before transmission. Server aggregates encrypted updates — data stays confidential even if the aggregator is compromised.

GLOBAL AGGREGATOR

Encrypted Addition: 〚W₁〛 + 〚W₂〛

FedAdam Optimizer ▸ Decrypt → W_global

BROADCAST W_global

CLIENT A ← W_global

CLIENT B ← W_global

Traffic Interceptor

Contrasts plaintext parameters with scrambled ciphertexts. SHAP force plots show feature impact on diagnostic predictions.

PLAINTEXT READABLE — VISIBLE

{
  "layer_1.weights": [
    0.042, -0.113, 0.897,
    -0.224, 0.531, 0.008
  ],
  "layer_1.bias": [0.012, -0.045],
  "accuracy": 0.934
}

CIPHERTEXT ENCRYPTED — HIDDEN

c0: 0x4a3f8b2c...
c1: 0xe71d05a9...
c2: 0x9b41f36e...
⋮ (512-bit ciphertext)

Encryption Optimization

Selective Homomorphic Encryption encrypts only critical FC layers. Vectorized slot-packing reduces ciphertext bloat.

STANDARD HOMOMORPHIC ENCRYPTION HIGH OVERHEAD

INPUT

ALL ENCRYPTED

OUTPUT

SELECTIVE HOMOMORPHIC ENCRYPTION LOW OVERHEAD

INPUT

FEATURE EXTRACT

FC ONLY [ENC]

OUTPUT

Vectorized Slot-Packing — Visual Encoding

// COMPACT CKKS BATCHES — MINIMIZES CIPHERTEXT SERIALIZATION BLOAT //

Defense-in-Depth

Trusted Contribution Module detects label-flipping and weight-scaling attacks. SHA-256 blockchain ledger. Token economics with staking and slashing.

DIFFERENTIAL PRIVACY

Calibrated Gaussian noise with Rényi DP accounts for privacy budget cumulative leakage.

TRUSTED CONTRIBUTION MODULE

Evaluates update metrics to drop labels and weight-scaling poison anomalies.

TAMPER-EVIDENT LEDGER

Local SHA-256 blockchain ledger ensures transparent model state auditable trails.

TOKEN ECONOMICS

Staking mechanics and slashing penalties govern client contribution trust.

Token Economics

REWARD / SLASH Economic result

SHAP Explainability

PREDICTION: CARDIAC RISK f(x) = 0.87

Base: 0.50

−0.12

Age

HR +0.21

ECG +0.15

+0.08

← Lower Risk Base (0.50) Higher Risk →

// SHAP DECOMPOSITION — EACH FEATURE'S CONTRIBUTION TO PREDICTION //

Technology Stack

Core EnginePyTorch & FastTensors

EncryptionTenSEAL (Microsoft SEAL — CKKS)

Differential PrivacyOpacus (Rényi DP Accounting)

Server EndpointsFastAPI / WebSockets

Interactive UIStreamlit & SHAP XAI

Blockchain AuditSHA-256 Local Ledger

AegisMesh Dashboard

DASHBOARD TYPE: STATIC FRONT-END // DEPLOYMENT: INDEPENDENT // STACK: HTML/CSS/VANILLA JS

Static front-end with a 3D WebGL globe, network monitor, model marketplace, federation builder, ledger view, and tokenomics tracking.

System Architecture

SECUREFL ENGINE

Fed Training Loop

CKKS Crypto

Token Ledger

SHAP XAI

AEGISMESH DASHBOARD

3D Globe

Net Monitor

Marketplace

Fed Builder

Ledger View

Tokenomics

Dashboard Core Modules

3D Network Globe

WebGL globe with client distribution, data flow arcs, and orbit controls.

Live Network Monitor

Active connections, bandwidth, latency, and encrypted throughput per node.

Model Marketplace

Browse pre-trained models with accuracy, encryption status, and provenance data.

Federation Builder

Configure training tasks — cohorts, round params, CKKS levels, privacy budgets.

Blockchain Ledger

SHA-256 ledger with tamper-evident records for every round and transaction.

Tokenomics Tracking

Leaderboards for stakes, balances, rewards, and slashing penalties.

WebGL Rendering

Four-stage pipeline: geo-indexing → client activity stream → render loop → dashboard composite.

STAGE 01: GEO-INDEXING

IP geolocation resolves client coordinates. Nodes clustered by region into color-coded continent groups.

STAGE 02: CLIENT ACTIVITY STREAM

WebSocket pipe pushes real-time events: node status, training progress, token transactions, encrypted submissions.

STAGE 03: WEBGL RENDER LOOP

Three.js compositor projects 3D coordinates. Animated bezier arcs pulse data flows. Globe auto-rotates with orbit controls.

STAGE 04: DASHBOARD COMPOSITE

Overlaid UI panels consume the rendered globe as canvas background, updating metric cards, leaderboards, and ledger tables.

3D Network Globe

Tokenomics Leaderboard

Real-time leaderboards with staking, slashing, and token balance updates alongside model performance.

RNK CLIENT STAKE BALANCE ACC

// REAL-TIME TOKENOMICS — STAKING, REWARDS, SLASHING //

Dashboard Technology Stack

Front-EndHTML5 / CSS3 / Vanilla JavaScript

3D RenderingWebGL — Custom Three.js Glove Compositor

Data TransportRESTful API / WebSocket

Backend BridgeFastAPI — SecureFL Engine Connection

DeploymentIndependent Static Host — No Framework Bundle

[ Screenshots and Media will be added soon ]
Request

[ MONITOR PANEL ]

[ FED BUILDER ]

[ TOKENOMICS ]

Gamified AI-Assisted Study Platform

AI-Driven Academic Preparation

A highly interactive, full-stack, gamified spatial learning ecosystem and academic preparation platform.

Tags: Frontend, AI

Gamified AI-Assisted Study Platform

Full-stack gamified study platform with a 3D virtual room, document annotation, Socratic AI coaching, and collaborative channels.

Extraction & Knowledge Pipeline

Multi-stage pipeline parses PDFs and feeds contextual prompts to Gemini. Tree-traversal algorithms transform syllabi into force-directed knowledge graphs.

STAGE 01: INGESTION

Asynchronous per-page text stream parsing & coordinate layout extraction via PyMuPDF.

STAGE 02: STRUCTURING

Tree-traversal algorithms transform hierarchical syllabi into a 2D force-directed node graph.

STAGE 03: SYNTHESIS

Contextual prompts feed Gemini 2.5 Flash-Lite for Socratic coaching and MCQ generation.

Interactive Spatial Environment

3D scene with bloom, vignettes, and a custom gooey navbar. Canvas overlay for PDF highlight/underline. Draggable AI notes with child-node spawning.

PERFORMANCE ENGINEERING WebGL power preferences, memoization, and Off-Screen Canvas keep interactions smooth. Also includes collaborative chat rooms.

Technology & Optimizations

Core InfrastructureNode.js, Express, MongoDB, Socket.io

AI & ParsingGemini API, PyMuPDF (fitz)

3D EnvironmentReact Three Fiber, Drei, Postprocessing

UI FrameworkReact 18, Router v7, Framer Motion, GSAP

Optimization LayerKey Rotator, Canvas Memory GC, Memoization

[ Screenshots and Media will be added soon ]
Request

Interactive 2D SPH Fluid Simulation

Physics Simulation

A real-time, particle-based fluid solver built from scratch in C++ and OpenGL. It uses Smoothed Particle Hydrodynamics (SPH) to simulate realistic liquid behavior.

Tags: Graphics, Backend

Interactive 2D SPH Fluid Simulation

Real-time particle-based fluid solver using SPH. Runs at 60+ FPS with 2,500+ particles. Interactive mouse forces and a live obstacle editor.

Performance Optimization

Spatial grid hashing avoids O(N²) lookups. Radix sort groups particles in memory. OpenMP parallelizes the physics loop across CPU cores.

Lookup Complexity

// CALCULATED FOR N = 2,500 PARTICLES //

Physics Pipeline

Fluid Physics & Stability

Uses a dual-density model with near-pressure formulation to prevent particle clumping — a common SPH instability.

STANDARD SPH

Clumping Instability

Particles unnaturally group at negative pressures due to standard kernel deficiencies.

MODIFIED SPH

Dual-Density Model

Near-pressure formulation generates strong repulsion at short distances, preventing clustering.

// VISUALIZATION & DEBUG Particle velocity mapped to color spectrum. Includes toggleable density gradients, compression heatmaps, and spatial grid overlay.

Tech Stack

Languages & APIsC++17, OpenGL, GLFW

User InterfaceDear ImGui

PerformanceOpenMP, C++ Parallel STL, VTune

[ Screenshots and Media will be added soon ]
Request

Syntactic Knowledge Navigation and Packing

Context Intelligence Engine

An advanced context intelligence engine that analyzes large-scale codebases and packs highly relevant semantic slices into constrained token budgets for large language models.

Tags: AI, Backend

Syntactic Knowledge Navigation and Packing

Analysis engine that packs relevant code slices into LLM token budgets. Uses Joern CPG, Tree-sitter ASTs, LanceDB, and LLM summarization. CLI query interface.

System Architecture Pipeline

CODE INGESTION

Joern CPG & Tree-sitter AST parsers extract structural and syntactic code representations.

Python/Tree-sitter

GRAPH CONSTRUCTION

Multi-layer NetworkX graph models AST, CFG, and PDG as queryable nodes and edges with cross-layer traversal.

NetworkX

SCORING ENGINE

Context Weight Score computed across 6 normalized structural metrics per code node via percentile rank.

Percentile Rank

PACKING ENGINE

Greedy knapsack solver, dynamic slot partitioning, and proactive dependency reservation.

cl100k_base

OUTPUT & INTEGRATION

CLI terminal, force-directed visualizations, and MCP server for IDE plugin integration.

MCP / CLI

Context Weight Score

Multi-metric score balancing cyclomatic complexity, coupling, module boundaries, call depth, and PageRank — percentile-normalized to prevent scale compression.

// WIDTH REPRESENTS RELATIVE WEIGHT CONTRIBUTION — PERCENTILE NORMALIZED //

Multi-Layer Semantic Graph

NetworkX models AST, CFG, and PDG as queryable layers. One-hop program slicing for behavioral dependency analysis.

AST LAYER

Abstract Syntax Tree. Hierarchical syntax nodes parsed via Tree-sitter representing code structure.

CFG LAYER

Control Flow Graph representing sequential execution paths and branching logic.

PDG LAYER

Program Dependence Graph enabling data dependency and one-hop program slicing.

Performance

PageRank proxy replaces O(n³) betweenness centrality. Global dedup prevents cyclic imports from wasting the token budget.

PAGERANK PROXY

Replaces O(n³) betweenness with PageRank centrality on subgraphs for 10-100x speedup.

GLOBAL DEDUP STATE

Tracks redundancies to prevent cyclic imports from consuming token budget.

OUTLINE MODE

Strips method bodies from large files, extracting only signatures for structural details.

KNAPSACK PACKING

Dynamic slot partitioning and dependency reservation prevent token budget overflow.

Query Routing

Louvain community detection groups files into feature clusters. Regex classifier routes queries to specialized packing strategies.

RELEVANCE-FIRST

Top-K scoring nodes packaged first.

DEPENDENCY-FIRST

Walks transitive closure of program dependencies.

BREADTH-FIRST

Wide module coverage with shallow dependency depth.

ADAPTIVE MODE

Mixed packing strategies dynamically auto-selected.

Technology Stack

Core APIsPython 3.12+, Typer CLI, Joern, Tree-sitter

LLM & StorageGemini API, LanceDB Vector DB, cl100k_base

Graph EngineNetworkX, Louvain, PageRank, Program Slicing

VisualizationsMatplotlib, Cosmograph, Rich Terminal

IntegrationMCP Server, IDE Plugin Bridge

[ Screenshots and Media will be added soon ]
Request

AI-Powered Web Security & Vulnerability Scanner

Software Engineering Consultant — Nov 2025 – Mar 2026

An automated security auditing platform built with FastAPI and Playwright that deeply scans dynamic websites for PII leaks and OWASP Top 10 vulnerabilities, reducing manual security review time by over 80% and securing 50+ critical exposures in client web assets.

Tags: FastAPI, Playwright, OWASP, Python, Security, Audit

AI-Powered Web Security & Vulnerability Scanner

Scan Pipeline

Five-stage pipeline — URL to structured security report with zero manual intervention.

STAGE 01: TARGET INGESTION

URL submission, scope definition, authentication profiles, and crawl-depth configuration.

STAGE 02: RECONNAISSANCE

Headless Playwright browser crawls all routes, submits forms, and maps the full attack surface.

STAGE 03: ANALYSIS ENGINE

Parallel OWASP checks, PII pattern matching, entropy scanning, and JavaScript AST parsing.

STAGE 04: CLASSIFICATION

Severity scoring, false-positive filtering, CWE/CVE mapping, and priority assignment.

STAGE 05: REPORTING

Structured JSON/HTML report generation with remediation guidance and severity heatmaps.

Impact Metrics

MANUAL REVIEW TIME

100% −80%

Manual baseline 80% reduction

CRITICAL EXPOSURES

0 50+ secured

API KEYS PII LEAKS TOKENS

Scan Scope Funnel

Pipeline progressively filters thousands of data points down to verified, exploitable vulnerabilities.

RAW DATA POINTS 12,400+

Requests, scripts, endpoints, forms discovered

ANOMALIES DETECTED 1,180

~9.5% flagged by pattern + entropy analysis

VERIFIED VULNERABILITIES 127

~1% — confirmed, classified, CWE-mapped

CRITICAL EXPOSURES 52

Immediate remediation deployed

Entropy Analysis — Secret Detection

Shannon entropy computed for every string token. High-entropy matches are flagged — catching secrets that regex-only scanners miss.

sk_live_cJ1udzKJX78T3Rkd9M0tKt2s // Stripe Live Key

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0 // JWT (no sig)

Welcome to our platform. Please sign in to continue. // Safe string

// SHANNON ENTROPY — EACH TOKEN SCORED, CLASSIFIED, AND TRIAGED //

OWASP Top 10 Coverage

Specialized detection modules covering the OWASP Top 10 (2021).

A01 — Broken Access Control

Privilege escalation, IDOR, path traversal

A02 — Cryptographic Failures

Weak TLS, exposed secrets, hardcoded keys

A03 — Injection

SQL, XSS, NoSQL, template injection

A04 — Insecure Design

Missing rate limits, weak flow logic

A05 — Security Misconfiguration

Default creds, debug endpoints, CORS misconfig

A06 — Vulnerable Components

Outdated libraries, known CWEs

A07 — Identification & Auth Failures

Session flaws, weak passwords, JWT issues

A08 — Software & Data Integrity

Partial — CI/CD pipeline scanning only

A09 — Security Logging & Monitoring

Missing headers, debug info in responses

A10 — SSRF

Server-side request forgery detection

Detection Categories

Each finding tagged with one of six detection categories for rapid triage.

PII Leaks

Emails, phones, SSNs, addresses

API Keys

Stripe, AWS, GitHub, OpenAI tokens

Credentials

Hardcoded passwords, basic auth

Secrets

JWT, OAuth, session tokens

Internal Paths

Source maps, admin routes, .env

Info Leaks

Stack traces, debug output, version disclosure

Technology Stack

FrameworkFastAPI (Python 3.11)

Browser EnginePlaywright (Headless Chromium)

AnalysisRegex Pipeline, AST Parser, Shannon Entropy

ReportingJSON, HTML, SARIF (Static Analysis Results)

DeploymentDocker, Railway, Vercel Serverless

[ Screenshots and Media will be added soon ]
Request

World UI

Embedded interface

Embedded world-space UI prototype that smoothly morphs between fullscreen interface mode and perspective-skewed in-world geometry.

Tags: Three.js, CSS 3D, Troika Text, Animation

World UI

Embedded world-space UI prototype that smoothly morphs between fullscreen interface mode and perspective-skewed in-world geometry.

Achievements & Info

1st Place — National-Level Hackathon

DOMAIN: FEDERATED LEARNING, FOCUS: PRIVACY-PRESERVING ML, TECH: PYTORCH, TENSEAL, OPACUS

1st Place Winner, National-Level Hackathon (800+ participants)

Architected a novel privacy-preserving Federated Learning (FL) platform combining Homomorphic Encryption (CKKS) with Differential Privacy (ε-DP) — enabling collaborative ML across decentralized datasets without exposing raw data.

Tags: 1ST PLACE, NATIONAL HACKATHON, FEDERATED LEARNING

1st Place — National-Level Hackathon

DOMAIN: COMPUTER GRAPHICS, FOCUS: FLUID SIMULATION, TECH: C++, OPENGL, GLSL

1st Place Winner, National-Level Hackathon — Best Project

Awarded First Prize at VisionTech 2025 in the category of Project Presentation for the solo project "Interactive 2D SPH Fluid Simulation" — a real-time particle-based fluid solver with spatial hashing, Radix Sort, and dual-density physics.

Tags: 1ST PLACE, BEST PROJECT, SPH SIMULATION

1st Place — Best Paper Presentation

DOMAIN: COMPUTER GRAPHICS, FOCUS: FLUID SIMULATION, TECH: C++, OPENGL, GLSL

1st Place Winner Best Paper Presentation

Awarded First Prize at VisionTech 2025 in Paper Presentation for "Real-Time Fluid Simulation via Smoothed Particle Hydrodynamics" — a deep dive into GPU-accelerated particle systems and custom GLSL shader pipelines.

Tags: 1ST PLACE, BEST PAPER, SPH SIMULATION

Top 5 — National-Level Tech Expo

DOMAIN: COMPUTER GRAPHICS, FOCUS: FLUID SIMULATION, TECH: C++, OPENGL, GLSL

Hackathon Finalist (Top 5), National-Level Tech Expo (600+ participants)

Recognized at National "Nirmaan: Tech Skill Expo 2024" with a 5th Position prize. Additionally honored as a first-year student and the sole solo participant for an innovative Fluid Simulation project using SPH physics.

Tags: TOP 5, TECH EXPO, SPH SIMULATION

Top 10 — Highest Innovation Score

DOMAIN: 3D WEB + AI, FOCUS: GAMIFIED LEARNING, TECH: THREE.JS, REACT, BLENDER

Hackathon Finalist, National-Level (600+ Participants): Top 10 Position & Highest Innovation Score

Developed a 3D website AI-assisted study platform utilizing gamified incentives for learning — incorporating Knowledge Graphs, Skill Trees, and Course Textbook-based assistance. Built with Three.js, React, and Blender within 36 hours on venue.

Tags: TOP 10, HIGHEST INNOVATION, GAMIFIED LEARNING

Top 10 — National-Level Hackathon

DOMAIN: P2P NETWORKING, FOCUS: E2E ENCRYPTION, TECH: JAVA, WEBRTC, WEBSOCKETS

Hackathon Finalist National-Level (Top 10)

Engineered a privacy-preserving peer-to-peer chat application with end-to-end encryption via WebRTC data channels and WebSocket signaling — achieving sub-100ms message delivery with zero server-side data retention.

Tags: TOP 10, NATIONAL HACKATHON, P2P CHAT