Archive

Built SentinelMesh, an integrity-focused observability layer for Solana that runs a distributed mesh of sentinel agents to probe heterogeneous RPC/validator endpoints, detect consistency and censorship-resistance anomalies, and publish signed, replayable telemetry through an aggregation API with durable PostgreSQL storage and operator-grade dashboards/metrics.

Designed InvariantSplit as a deterministic ETH settlement primitive with a deliberately small execution plane: fixed recipients, conservation rules, and atomic failure semantics. The assurance layer includes formal specification, property and differential tests, signed release manifests, runtime attestation, and published on-chain evidence.

Developed Veritas, an enterprise-grade StarkNet voting system built in Cairo with commit–reveal semantics and ZK-oriented security controls to reduce herd bias, support multi-phase governance workflows, and provide auditability, access control, and failure-mode handling for adversarial community decision-making.

Implemented Exalto, a modular Layer-1 blockchain focused on correctness and deterministic execution, featuring a hardened HotStuff-style consensus pipeline, BLS quorum cryptography, QUIC transport with typed channels, authenticated storage primitives, and CI-wired formal/differential tooling for consensus and state-machine validation.

Designed Aetherlink as an edge-oriented decentralized data-bundling and validation system using Substrate and Rust. The architecture combines on-chain bundle verification, GPS-backed movement validation, clustering analytics, and offline-first collection flows to preserve IIoT telemetry integrity under hostile or intermittent network conditions.

Created IPE (Infrastructure Policy Engine) as part of SentinelStack: a Rust static-analysis tool for Terraform/Ansible that enforces security/compliance policies with CI-friendly JSON outputs, fast scanning paths, and guardrails against common IaC failure modes (open ingress, missing tags, insecure secret handling).

Developing Whispyr as a Rust secure-communications protocol for adversarial environments, combining P2P networking, hybrid post-quantum handshakes, capability-based ephemeral identities, and metadata-resistance strategies. The protocol work centers on confidentiality, replay resistance, routing privacy, availability under censorship pressure, and explicit separation between identity, transport, and message-security layers.

Built NeuroTradeX, an explainable AI-driven trading stack spanning real-time data pipelines, model training/evaluation, execution and risk controls, a dashboard UI, and alerting—designed to be modular, production-oriented, and auditable for both traditional and crypto markets.

Aegis is a Solana security operations infrastructure project focused on protocol operations security, governance assurance, and runtime policy enforcement. The system is designed around explicit operational invariants for high-risk on-chain actions, reducing reliance on discretionary operator behavior by making governance controls, execution constraints, and security posture observable and enforceable.

AxiomX is a cross-chain transport layer that enforces safety invariants at the protocol boundary. Cross-domain messages are verified against light-client commitments, Merkle inclusion proofs, replay-protection rules, and machine-checked correctness properties instead of relying on trusted relayers, multisigs, or opaque off-chain coordination.

WitnessChain is a sovereign post-quantum layer-1 blockchain architecture with pre-genesis trust anchoring, threshold witness governance, and sealed computation. The design treats validator and witness coordination, key lifecycle, governance authority, and computation sealing as explicit protocol invariants rather than operational conventions.

zK-PQC is a layer-0 cryptographic infrastructure project for deterministic hash-based post-quantum signatures, including WOTS+ and XMSS, optimized for STARK-based zero-knowledge execution environments such as the Cairo VM. The design relies on symmetric hash assumptions and formal semantic structure to avoid the proof-cost and circuit-complexity surfaces that make lattice-based post-quantum constructions difficult to compose inside zk execution systems.

Developed HyperLattice-Sign as a Rust post-quantum signature research implementation exploring compact signature formats, verification efficiency, side-channel-aware implementation boundaries, and multi-platform deployment surfaces including no_std, WebAssembly, and FFI contexts. The project is framed around cryptographic agility and implementation discipline rather than novel primitive invention.

Architected a post-quantum Bitcoin migration toolkit exploring consensus-adjacent script changes, quantum-resistant spending paths, and Rust-based wallet migration tooling. The work focuses on backward-compatible migration mechanics, UTXO transition safety, node-level verification hooks, and the operational realities of moving long-lived assets toward quantum-resilient controls.

Developed PQC-IIoT as a Rust framework for post-quantum security in industrial IoT environments, integrating Kyber-style key establishment and Falcon-style signatures for constrained communication and key-management workflows. The design focus was cryptographic agility, latency discipline, device constraints, and migration paths for long-lived industrial systems.

Engineered Quantum-Tunneler as a Rust-based quantum-resistant VPN research stack, including modular IPSec components, IKEv2-oriented key exchange, and post-quantum KEM/signature integration. The design emphasizes cryptographic agility, no_std-compatible boundaries, handshake failure analysis, and migration patterns for secure network tunnels under harvest-now-decrypt-later assumptions.

Worked on machine-learning and MLOps infrastructure for AI-assisted video generation, including model experimentation, deployment pipelines, inference reliability, and operational scaling concerns. The engineering focus was reproducible model delivery, controlled runtime behavior, and maintainable infrastructure around compute-intensive media workflows.

Q-Trust Plane is a cryptographic zero-trust control plane designed to govern high-risk actions across hybrid Web2 and Web3 systems. It models privileged operations as policy-bound, verifiable workflows, using signed intents, chain-aware enforcement, auditability, and explicit execution constraints to reduce trust in operators, relayers, administrative interfaces, and off-chain coordination paths.

VSEL is a formally verified execution layer where an accepted proof implies that the corresponding execution is semantically valid under a mechanized formal specification. The project focuses on executable semantics, proof-carrying execution, refinement boundaries, and machine-checkable invariants that make invalid state transitions rejectable at the protocol layer.

Built InfraProxyStack, a self-hosted Rust platform fusing WireGuard VPNs and residential proxies with isolated fwmark/iptables routing, RESTful infrastructure control, health monitoring, and automatic failover to deliver secure, flexible, and resilient network paths.

Contributed to AI voice-model engineering for Murf using TensorFlow and PyTorch, with attention to model training workflows, inference behavior, multilingual scalability, and deployment constraints. The work focused on controlled model iteration, latency-aware serving, and operational reliability around generated speech systems.

Worked on trading-platform infrastructure with emphasis on backend determinism, signal ingestion, indicator computation, and transaction-sensitive execution paths. The engineering focus was reliability under high event volume, predictable platform behavior, and clear separation between market-data processing, user-facing workflows, and financial state transitions.

Reworked DevSecOps, Infrastructure as Code, and CI/CD paths for JugaBet with emphasis on deployment reproducibility, service isolation, security controls, and operational observability. The work strengthened release discipline, reduced configuration drift, and created clearer boundaries between infrastructure provisioning, application delivery, and runtime monitoring.

Worked on backend, AI-service, and AWS infrastructure concerns for SleekFlow, using Infrastructure as Code and DevSecOps practices to improve deployment repeatability, scalability, and security posture. The architecture emphasized service reliability, controlled automation, and maintainable cloud operations for customer-engagement workflows.

Developed CPZKp as a Rust implementation of Chaum-Pedersen zero-knowledge proofs with multi-round session support, WebAssembly/Python bindings, secp256k1 and optional Curve25519 support, and Ethereum integration. The project emphasizes explicit transcript handling, verification correctness, interface discipline, and deployability across decentralized and embedded contexts.

Designed and deployed IIoT infrastructure for Indubal using Rust, MQTT, and OPC UA to connect edge devices, telemetry pipelines, and backend analytics. The architecture emphasized protocol translation, device identity, secure ingestion, operational monitoring, and predictable behavior under industrial connectivity constraints.

Architected and implemented IIoT infrastructure for Sinoplast using Rust and MQTT, connecting legacy industrial equipment to real-time monitoring and maintenance workflows. The system design emphasized secure telemetry ingestion, protocol boundary handling, observability, and maintainable integration with existing plant operations.

Worked on financial-platform infrastructure for Invesa Capital, including transaction confirmation flows, future-order handling, open-position tracking, and deposit/withdrawal workflows. The design focus was backend correctness, API reliability, data consistency, and risk-sensitive user journeys around real-time financial operations.

Contributed to casino-platform engineering with focus on streaming availability, backend reliability, and integration behavior across high-traffic user flows. Work centered on stable service boundaries, operational monitoring, and resilient delivery paths for continuously available web experiences.

Worked on mobile widget and privacy-sensitive photo-sharing flows, including limited-audience sharing, photo history, and recap generation. The implementation focus was user-data handling, reliable synchronization, and constrained mobile UX where private media, notification behavior, and local platform limitations must be treated as design boundaries.

Worked on mobile real-estate application capabilities for BostonPads, including property updates, listing workflows, and integration with existing real-estate systems. The work emphasized data freshness, API reliability, mobile performance, and coherent user flows for high-intent housing search.

Worked on casino-platform backend and delivery infrastructure, including real-time content surfaces, streaming availability, service integration, and operational reliability. The architecture prioritized uptime, predictable user-session behavior, and maintainable deployment paths for a traffic-sensitive entertainment platform.

Contributed to copy-trading and crypto execution infrastructure involving exchange integrations, strategy replication, signal pipelines, and backend reliability. Work emphasized deterministic execution workflows, failure handling around exchange APIs, and clear operational boundaries between signal generation, portfolio action, and user-facing reporting.

Worked on real-estate backend services using Go and distributed-systems patterns for listing data, API integration, and property workflow reliability. The architecture emphasized data freshness, service scalability, predictable API behavior, and operational visibility across frequently changing market data.

Worked on crypto trading automation infrastructure for Profit Farmers, including market-data ingestion, trade-plan workflows, copy-trading mechanics, and risk/reward planning features. The engineering focus was execution-oriented backend reliability, signal integrity, operational observability, and user-facing decision support without hiding the risk model behind opaque automation.

Implemented Odoo ERP modules and backend integrations across multiple business domains, with attention to workflow correctness, data consistency, access control, and maintainable customization boundaries. The work involved adapting ERP behavior without compromising long-term upgradeability or operational support.

Implemented security information and event-management capabilities alongside cloud-native application components. The work focused on event ingestion, alerting workflows, security telemetry, operational visibility, and infrastructure patterns that support incident detection and response in production environments.

Worked on casino-platform infrastructure with emphasis on always-on media delivery, backend service reliability, content availability, and user-session continuity. The implementation focus was operational resilience, integration stability, and predictable platform behavior under continuous traffic rather than cosmetic feature delivery.

Built a web and commerce platform for a design brand, covering catalog presentation, product flows, and customer-facing purchase paths. The implementation emphasized maintainable content structure, reliable checkout behavior, and a clear separation between presentation, inventory, and transactional workflows.

Worked on website, API, and subscription-platform capabilities for remote music collaboration and live recording workflows. The system involved scheduling, user/account flows, service integration, and backend reliability for coordinating distributed creative production teams.

Implemented an extensible OpenQASM compiler prototype focused on parsing, intermediate representation design, and deterministic transformation of quantum-circuit input. The project treated compiler behavior as a correctness problem, with attention to explicit syntax handling and future analysis passes.

Worked on web application and API surfaces for a housing marketplace serving students, young professionals, digital nomads, travelers, and families. The engineering focus was marketplace data modeling, search/listing workflows, API reliability, and user-facing flows around high-trust accommodation decisions.

Built a collection of OpenQASM algorithm examples for experimenting with quantum-circuit representation, instruction structure, and reproducible execution inputs. The repository serves as a practical corpus for compiler, simulator, and quantum-programming workflow validation.

Built a Next.js landing-page prototype to explore component structure, static rendering, and responsive layout behavior. The work focused on clean implementation boundaries and reproducible frontend delivery for small web experiences.

Worked on datacenter and infrastructure implementation involving cloud services, blockchain-adjacent workloads, deployment reproducibility, and operational reliability for large-scale environments in Norway. The work emphasized physical and logical infrastructure boundaries, service hardening, and maintainable operations for compute-heavy platforms.

Worked on field-documentation infrastructure for CompanyCam, including GPS and timestamped photo capture, live project feeds, document scanning, annotations, checklist workflows, and report generation. The system design emphasized event-driven integration with CRM/FSM ecosystems, reliable metadata handling, and operational workflows where photos, documents, and field events must remain attributable and auditable.

Built a terminal-based chat prototype using Node.js, Neo-Blessed, Axios, and Ora to explore text-mode interaction, client-side state, and networked message flows. The project focused on minimal UI constraints, event handling, and pragmatic terminal application design.

Implemented a Python self-replication experiment as a controlled study of file-system behavior, execution boundaries, and why self-modifying code must be treated carefully in security-sensitive environments. The project is intentionally archival and educational, not production tooling.

Built a frontend interaction prototype using HTML, CSS, JavaScript, and GSAP to explore scroll-driven motion, landing-page composition, and animation timing. The work was intentionally scoped as an interface experiment with emphasis on deterministic rendering and maintainable animation structure.

Participated in trading-platform engineering involving blockchain-facing components, Solidity-oriented integrations, Rust services, real-time data flows, and event-processing logic. The work emphasized transactional correctness, platform reliability, signal integrity, and consistent behavior across user-facing financial workflows.

Worked on multi-cloud networking and security concerns involving authentication, traffic control, integration reliability, and performance behavior across heterogeneous environments. The focus was secure connectivity, predictable network boundaries, and operationally maintainable infrastructure for distributed application deployments.

Built a Vue/Firebase note-taking prototype to explore realtime persistence, simple state synchronization, and client-side interaction patterns. The implementation focused on predictable CRUD behavior, lightweight data modeling, and rapid frontend/backend iteration.

Built a life-sciences investment website with structured content, responsive presentation, and maintainable publishing workflows. The project focused on information architecture, performance, and predictable delivery for an institutional web presence.

Delivered DevOps, security, and ERP platform work across client environments, including Odoo module implementation, deployment automation, infrastructure configuration, and operational support. The work emphasized maintainable backend processes, controlled change management, and security-aware service delivery.

Built a note-taking prototype with persistent storage and lightweight interaction flows. The project explored local data modeling, synchronization assumptions, and simple UX patterns for capture, retrieval, and editing of user-generated content.

Built a browser-based weather application integrating Geolocation and OpenWeatherMap APIs. The project focused on permission-aware client behavior, external API integration, error handling, and clear presentation of time-sensitive environmental data.

Delivered a healthcare-focused web platform with Algolia-backed instant search and structured content workflows. The implementation emphasized reliable search behavior, maintainable content modeling, and clear interaction boundaries for a user-facing healthcare experience.

Implemented an SMTP client prototype in Deno to explore runtime security boundaries, network I/O, and explicit protocol handling in a modern JavaScript/TypeScript environment. The project focused on low-level message flow, transport behavior, and dependency-light implementation.

Built an installation automation script for Odoo ERP environments, reducing manual setup variance across dependencies, service configuration, and deployment steps. The work focused on repeatability, operational simplicity, and safer bootstrap paths for ERP infrastructure.

Created a frontend landing-page prototype using GSAP animation to evaluate motion timing, layout composition, and responsive interaction behavior. The project is a focused UI engineering exercise rather than a production service.

Designed and maintained a cross-editor developer theme spanning VS Code, Sublime Text, Atom, iTerm, Hyper, and related tooling. The work focused on consistent syntax semantics, visual ergonomics, and reproducible theming across heterogeneous developer environments.

Developed a machine-learning experiment for estimating burned forest area from environmental input data. The project focused on feature handling, model experimentation, and the operational limits of predictive systems where data quality and uncertainty must remain explicit.

Implemented a WebRTC signaling/server prototype for video-chat workflows, focusing on session negotiation, connection setup, and network coordination between browser clients. The work explored the operational boundary between signaling services and peer-to-peer media transport.

Built a custom headless CMS using Node, Express, and Firebase for a mobile application workflow. The system focused on content modeling, API boundaries, permissioned publishing, and reliable synchronization between editorial operations and client-facing application state.

Built a URL-shortening service using MongoDB, Node.js, and Express to explore request routing, identifier generation, persistence, and redirect behavior. The implementation focused on simple API boundaries, predictable storage semantics, and basic abuse considerations around public redirect services.

Created a typography-focused web experiment for evaluating font pairings, layout rhythm, and content presentation. While intentionally small, the project reflects attention to interface composition, reusable styling, and deterministic rendering behavior across browsers.

Built a MEAN-stack course-browsing application for Northeastern students, focusing on structured academic data, searchability, and a more predictable course-discovery workflow. The project emphasized pragmatic backend modeling, API-driven UI behavior, and maintainable web application architecture.

Archival DevSecOps prototype for injecting network faults, malformed inputs, timing variation, and configuration drift into CI workflows. The harness treated adversarial testing as a regression mechanism for backend reliability, deployment reproducibility, and security-critical failure containment.

Implemented a campaign-support site for JetBlue's HumanKinda program, including interactive quiz behavior and content integration around the documentary campaign. The work focused on reliable frontend execution, campaign-specific interaction design, and consistent delivery within an existing publishing platform.

Built a student portal redesign prototype informed by iterative user testing and workflow analysis. The project focused on reducing navigation ambiguity, improving information architecture, and validating interaction assumptions before implementation.

Implemented and hardened device protocol support for Traccar, with focus on authentication, input validation, telemetry correctness, and backend reliability. The work required careful handling of heterogeneous device behavior, malformed payloads, transport failures, and security-sensitive location data.

Archival edge-infrastructure prototype for enforcing device policy, message admission, and telemetry routing near constrained industrial environments. The design focused on separating device identity, transport authorization, policy evaluation, and backend forwarding to contain failures close to the source.

Contributed to OpenERP/Odoo educational-management modules for administrative workflows, academic records, institutional processes, and reporting. The implementation focus was structured business logic, data integrity, access control, and maintainable ERP customization for education-sector operations.

Built an interactive conference website for Northeastern's student-led Interventions design event. The project emphasized event information architecture, responsive interaction design, and reliable content delivery for a time-bound public program.

Built a database-backed web application for browsing, filtering, and reviewing Lonely Planet destination data. The project focused on relational data modeling, queryable user workflows, and clear separation between data storage, filtering logic, and presentation.

Archival formal-methods lab for specifying protocol actors, message transitions, safety properties, and failure cases before implementation. The work used state-machine modeling to expose illegal transitions, replay surfaces, and ambiguous recovery behavior in distributed protocols.

Developed OpenERP 6.0 core components and business modules spanning communication, stock management, finance, and email workflows. The work required careful handling of transactional data, business-process state, permissions, and integration behavior in an extensible ERP architecture.

Archival backend architecture prototype for multi-region API services with explicit replication boundaries, degraded-mode behavior, and observability hooks. The system explored operational tradeoffs between latency, failover, consistency, and state repair in globally distributed service deployments.

Archival cryptographic-infrastructure prototype for coordinating key lifecycle operations, scoped credentials, and rotation procedures across backend services. The model separated key issuance, operational use, revocation, and audit trails to reduce blast radius during credential exposure or administrative error.

Archival IIoT prototype for bridging constrained device telemetry into backend ingestion services with explicit handling of intermittent connectivity, malformed payloads, and device-side resource limits. The design treated protocol translation, input validation, and durable forwarding as reliability and security boundaries.

Archival security-infrastructure prototype for collecting host and service events into a tamper-evident audit stream. The work emphasized evidence preservation, hash-linked records, operator accountability, and post-incident reconstruction under the assumption that parts of the runtime environment may already be compromised.

Archival distributed-systems lab focused on deterministic queue behavior under retry, partial failure, and overloaded consumers. The prototype modeled message ordering, duplicate suppression, bounded backpressure, and replay semantics as correctness properties rather than incidental implementation details.

Archival prototype for a capability-oriented service gateway where access was represented through scoped authority rather than ambient privileges. The design explored explicit trust boundaries, request authorization, failure containment, and auditability for network services operating under adversarial assumptions.

Archival research prototype exploring append-only event logging, hash-chained audit records, and deterministic log verification for security-sensitive systems. The work focused on making operational events tamper-evident, replayable for incident analysis, and useful as a primitive for later security monitoring and forensic workflows.