|
As the Chief Technology Officer at Magnyte Software, I specialize in building highly scalable, resilient, and secure systems that bridge the gap between complex engineering challenges and high-value business outcomes. I lead engineering teams, design microservices, and deploy production-grade software architectures from the ground up. I believe in code craftsmanship, rigorous automated verification, and architecting for security-first applications. I am passionate about developer productivity, local server hosting, and low-latency system communications.
|
|
- 🚀 B2B SaaS Architecture: Designed and scaled MySecureFolder from scratch, building advanced security controls, licensing systems, and Razorpay transaction networks.
- 🔒 Enterprise Dev Tooling: Built Magnyte Preview from the ground up, utilizing Cloudflare tunnels to stream secure localhost environments without complex deployments.
- 🔌 Local Dataplane Steering: Engineered the WiFi Balance multi-WAN platform in Rust, using Windows Filtering Platform hooks to route app-specific traffic.
- 🤖 Twilio OpenAI Realtime API: Designed Ava, a low-latency voice-driven AI call assistant that handles conversations using real-time Twilio Audio Streams.
🛠️ Project 1: MagnyteForge (GitVexo) — Enterprise SCM & DevOps
- Project Overview: An enterprise-grade, multi-tenant source code management (SCM) and DevOps platform built to optimize team collaboration and version control operations.
- Business Problem Solved: Offers a fully self-hosted, secure GitHub/GitLab alternative that enforces strict role-based/attribute-based access controls (RBAC + ABAC) and cloud-insulated repository compilation.
- Architecture: Modular API gateway built with Fastify, combined with simple-git for file system repository interaction, Redis for tasks queueing, and Prisma ORM for database connectivity.
- Tech Stack: React 18, Vite, Fastify, TypeScript, Prisma, MySQL 8.4, Redis, BullMQ, simple-git.
- Key Features:
- Isomorphic-Git sandboxed repositories.
- Granular RBAC + ABAC permissions.
- Session cookies, Argon2 hashing, TOTP MFA, and secure API keys.
- Scalability Considerations: Offloaded git sync computations to edge workers; asynchronous background workers handled intensive build payloads.
- Security Considerations: Integrated row-level security structures and cloud-insulated compilation environments.
- Engineering Challenges: Bypassing Git CPU spikes during concurrent requests. Solved by managing pre-warmed repository pools.
- Production-Readiness Highlights: Automated health check dashboards and zero-downtime rolling updates.
🛡️ Project 2: MySecureFolder — AES-256 Folder Lock & Zero-Knowledge SaaS
- Project Overview: An enterprise-grade desktop folder locker and secure synchronization client with dual-layer Wi-Fi bound security and zero-knowledge privacy.
- Business Problem Solved: Protects critical files locally against unauthorized physical access and network intrusion, while providing secure automated backups to the cloud.
- Architecture: Electron-based desktop app running native file system listeners and AES-256-GCM encryption threads, syncing with a Node.js SaaS API.
- Tech Stack: Electron, React, Node.js, Express, MongoDB, AWS S3, Razorpay, WebSockets.
- Key Features:
- Zero-knowledge encryption: Files encrypted client-side using user-held keys.
- Face Authentication and biometric logins.
- Wi-Fi bound local locking: Automatically locks folders if disconnected from authorized office/home Wi-Fi networks.
- Razorpay payment gates for SaaS subscriptions.
- Scalability Considerations: Implemented websocket-based real-time notification push to synchronize file statuses between client instances.
- Security Considerations: Dual-layer encryption (AES-256-GCM) with key stretching (PBKDF2) and secure on-device hardware storage.
- Engineering Challenges: Ensuring folder locking was bulletproof against Windows Explorer bypasses. Resolved by registering low-level system watcher hooks.
- Production-Readiness Highlights: Complete test suite spanning FaceAuth, cryptomanager, and Wi-Fi detector modules.
🖥️ Project 3: VPS Commander — Client-Side Mobile VPS Orchestrator
- Project Overview: A client-side, terminal-inspired Android mobile application designed to manage, monitor, and configure VPS servers remotely.
- Business Problem Solved: Eliminates the need for intermediary backend gateways by establishing direct, secure SSH/SFTP tunnels from the mobile client to hoster instances.
- Architecture: A fully client-side architecture with encrypted storage of credentials, running direct socket connections.
- Tech Stack: React Native, Expo,
@dylankenneally/react-native-ssh-sftp,expo-secure-store, JetBrains Mono. - Key Features:
- Encrypted multi-profile VPS store using Android Keystore.
- Dynamic Dashboard: Real-time CPU, RAM, disk, load averages, and uptime streaming.
- Interactive Terminal: Full PTY shell, exec-fallback, and ANSI color parsing.
- SFTP File Manager: Upload, download, edit, and share directory structures.
- PM2 Manager: List, restart, stop, and monitor live process logs.
- Scalability Considerations: Client-side execution eliminates the server scaling bottleneck entirely.
- Security Considerations: Credentials encrypted using AES-256 on-device via Android Keystore.
- Engineering Challenges: Maintaining active SSH channels and streaming terminal logs across mobile navigation screens without losing state. Solved using background navigation state-caching.
- Production-Readiness Highlights: Preconfigured EAS build pipelines for immediate APK compilation.
📞 Project 4: Ava — Twilio & OpenAI Realtime Phone Voice Agent
- Project Overview: A responsive AI phone assistant designed to handle voice calls, collect information, and answer customer queries naturally.
- Business Problem Solved: Automates incoming support lines with conversational AI, offering low-latency responses that mimic human operators.
- Architecture: Real-time bi-directional streaming pipeline linking Twilio's Audio Streams to OpenAI's Realtime WebSocket interface.
- Tech Stack: Node.js, WebSockets, Twilio Media Streams, OpenAI Realtime API (GPT-4o-mini-realtime-preview).
- Key Features:
- Low-latency bi-directional voice conversation.
- Intelligent interruption handling (stops speaking when user interrupts).
- Multi-threaded user state tracking and secure data harvesting.
- Scalability Considerations: Scaled websocket event handlers using stateless Node processes.
- Security Considerations: Secured webhook routes using cryptographic signature validation from Twilio.
- Engineering Challenges: Keeping latency below 300ms. Solved by streaming raw audio buffers directly without intermediate disk writes or conversion.
- Production-Readiness Highlights: Custom exception handling for connection dropouts and auto-reconnections.
🌍 Project 5: LocalNet Mobile — On-Device Mobile Web Server
- Project Overview: An Android application that transforms any smartphone into an offline local server capable of hosting full-stack codebases.
- Business Problem Solved: Facilitates developers and teams working in disconnected environments by enabling localized server infrastructure.
- Architecture: Embedded Node.js runtime thread running on-device, interacting with native storage and network interfaces.
- Tech Stack: React Native, Expo,
@comapeo/nodejs-mobile-react-native, Express, SQLite, Python. - Key Features:
- Run full Node.js or Python Flask backend servers on-device.
- Upload ZIP file codebases, extract, and statically host them.
- Automated server port isolation and crash auto-restarts.
- Scalability Considerations: Zero server footprint; load is distributed to on-device hardware.
- Security Considerations: Isolated sandbox storage directory on Android to prevent server processes from accessing unauthorized directories.
- Engineering Challenges: Compiling and running standard npm dependencies on an ARM-based Android CPU. Resolved by pre-bundling a node asset directory.
- Production-Readiness Highlights: Lightweight execution optimized to prevent battery drain.
🦀 Project 6: WiFi Balance — Desktop Multi-WAN Routing Controller
- Project Overview: A fully local desktop application designed to orchestrate and balance network traffic across multiple internet connections.
- Business Problem Solved: Combines multiple Wi-Fi, Ethernet, and mobile hotspot connections to increase bandwidth and provide automatic failover.
- Architecture: Master-agent architecture where a local Rust daemon executes system routing changes, communicating with an Electron interface via IPC Named Pipes.
- Tech Stack: Electron, React, Rust (
network-engine), Windows WFP (Windows Filtering Platform), WinDivert. - Key Features:
- Per-process routing using Windows Filtering Platform policies.
- Experimental packet steering with WinDivert capture and reinjection.
- Local configuration storage (no external server dependency).
- Scalability Considerations: Native Rust background daemon ensures negligible CPU and RAM overhead.
- Security Considerations: Requires administrative privileges; IPC communication is restricted to local Named Pipes.
- Engineering Challenges: Bypassing Windows routing table limitations to route individual apps through specific adapters. Resolved using low-level WFP connection policies (
FwpmConnectionPolicyAdd0). - Production-Readiness Highlights: Fully packaged MSI and EXE installers with automatic daemon lifecycles.
📋 Project 7: Svayam CMS — Command Center Complaint Portal
- Project Overview: An enterprise Complaint Management System (CMS) backend and frontend designed for municipal Integrated Command and Control Centers (ICCC).
- Business Problem Solved: Modernized a legacy Django administration portal into a lightweight, high-performance Node.js service without altering existing API routes or schemas.
- Architecture: Node.js/Express service utilizing raw MySQL connection pools to maximize query speeds and match legacy database schemas.
- Tech Stack: Express.js, React (Vite), mysql2/promise, JWT, Multer, Nodemailer.
- Key Features:
- Live complaint tracking and technician assignment logs.
- Custom JWT session middleware with in-memory OTP verification.
- Raw SQL query architecture for high database throughput.
- Scalability Considerations: Replaced Django's ORM overhead with raw, indexed MySQL queries, achieving a 5x increase in response times.
- Security Considerations: Clean middleware authorization layers restricting access based on user role rankings.
- Engineering Challenges: Replicating Django's custom cryptographic password hashing and schema structures. Solved by implementing compatible pbkdf2 and bcrypt wrappers.
- Production-Readiness Highlights: Thoroughly unit-tested to ensure API parity with the legacy Django service.
🎱 Project 8: 8-Ball Multiplayer Pool — Real-time Web Game
- Project Overview: A web-based multiplayer 8-ball pool game with interactive 2D physics and real-time multiplayer lobbies.
- Business Problem Solved: Demonstrates real-time state synchronization and client-side physics simulation.
- Architecture: Server-side room manager routing gameplay events to Matter.js physical engines, synchronized via WebSockets.
- Tech Stack: React 19, Vite, Matter.js (2D Physics), Socket.io.
- Key Features:
- Dynamic rigid-body physics for pool ball collisions, friction, and table bounces.
- Multi-user lobbies with matchmaking.
- Low-latency state synchronization.
- Scalability Considerations: Game state calculations minimized to run on the client, with validation checks on the server to prevent cheating.
- Security Considerations: Server-controlled authorization keys for room access.
- Engineering Challenges: Eliminating visual lag and stuttering in ball movements due to websocket latency. Solved by implementing client-side interpolation and physics extrapolation.
- Production-Readiness Highlights: Smooth 60fps canvas render loop.
💎 Project 9: G9 Jewellery — Custom E-Commerce Suite
- Project Overview: A specialized, high-traffic e-commerce storefront and admin control panel designed for custom jewelry retail.
- Business Problem Solved: Automates inventory listings, image uploads, price conversions, and client payments for high-value jewelry.
- Architecture: Multi-tier architecture splitting administrative portals, customer storefronts, and payment webhooks.
- Tech Stack: Node.js, Express, Knex, PostgreSQL/MySQL, AWS S3, Razorpay, Twilio, Puppeteer.
- Key Features:
- Automatic currency conversions and real-time pricing estimators.
- Integrated S3 image upload and resizing pipelines.
- Razorpay checkout flows with order tracking SMS notifications.
- Scalability Considerations: Implemented database pooling and query index optimization to handle high traffic spikes.
- Security Considerations: Strict JWT authentication, session handling, and Razorpay webhook signature verification to prevent transaction spoofing.
- Engineering Challenges: Generating high-fidelity invoice PDFs dynamically. Solved by using headless Puppeteer to print styled HTML pages.
- Production-Readiness Highlights: Integrated Swagger-UI documentation and automated transaction logs.
|
|
|
|
|
|
- Production Backend Systems: Extensive expertise in Node.js runtime environments using Fastify and Express to build low-latency, highly concurrent API microservices.
- Database Architectures: Designing secure MySQL, PostgreSQL, and SQLite databases using Knex or Prisma, combined with raw indexed SQL optimizations to speed up relational data fetches.
- Authentication & Access Control: Implementing JWT tokens, session cookies, TOTP MFA, face authentication, and granular multi-tenant row-level access control filters.
- Mobile & Desktop Sandboxing: Porting standalone Node.js and Python environments directly to Android devices via Expo, and implementing secure local folder lockers using Electron.
- Low-Level Networking: Orchestrating per-process and adapter-level routing tables in Windows using Windows Filtering Platform hooks and WinDivert packet captures.
- 3+ Years of professional engineering and technology leadership experience as a CTO.
- 10+ Real Production Systems designed, shipped, and actively maintained.
- 99.9% Service Uptime maintained across production SaaS and enterprise portfolios.
- 10k+ Active Users served daily via compliant business databases.
- 🤖 Agentic AI & Multi-Agent Workflows: Developing autonomous developer-agent tools utilizing LangChain and function-calling LLM models.
- 🧠 RAG (Retrieval-Augmented Generation): Designing high-efficiency semantic vector search indexes for legacy business compliance documents.
- ☁️ Nix & Declarative Environments: Engineering developer execution environments leveraging the reproducibility of Nix flakes.
- ⛓️ WebAssembly at the Edge: Exploring fast, lightweight execution of compiled C/Rust modules in web sandboxes.
"Software engineering is not just about writing lines of code; it is the art of translating human intent into highly optimized, fault-tolerant digital infrastructure."