As a Computer Engineering student at IOE Thapathali Campus, my work often bridges the gap between software logic and physical hardware. While building web applications and visualizers is exciting, engineering physical solutions that can impact real-world safety brings a completely different level of fulfillment.

For one of my core hardware engineering projects, I designed and developed an IoT-Based Emergency Response System for the Elderly, powered by an ESP32 microcontroller, integrated motion and biopotential sensors, and a custom-fabricated printed circuit board (PCB).

The Problem It Solves

Traditional emergency response systems for elderly or vulnerable individuals often rely on manual triggers or stationary panic buttons, which may not be accessible if a fall or medical emergency occurs suddenly.

The goal of this project was to build an automated, low-latency, and reliable IoT alert system that:

• Detects Anomalies Quickly: Uses motion sensors and biometric tracking to identify sudden changes or distress events.

• Triggers Immediate Alerts: Automatically transmits distress signals over Wi-Fi via an ESP32 microcontroller to notify designated caregivers or emergency contacts.

• Ensures Hardware Reliability: Integrates a custom-designed PCB layout to keep components compact, stable, and resilient against power noise.

Hardware Architecture & Tech Stack

Bringing this system to life required combining embedded C++ firmware with physical circuit design:

• Microcontroller Core: ESP32, chosen for its integrated Wi-Fi capabilities, dual-core processing, and low power consumption.

• Sensor Integration: Motion sensors and biopotential monitoring modules wired to capture real-time physical telemetry.

• Circuit Design & Prototyping: Designed schemas and simulated layouts using industry-standard tools before moving to custom PCB fabrication.

• Firmware Development: Written in C++, handling sensor polling, interrupt routines, and network requests to dispatch emergency alerts instantly.

Key Engineering Takeaways

• Handling Hardware-Software Interfacing: Debugging sensor signals taught me the importance of hardware debouncing, clean power regulation, and managing asynchronous interrupts on microcontrollers.

• PCB Fabrication Challenges: Moving from a breadboard prototype to a custom printed circuit board required rigorous trace routing to minimize signal interference and ensure structural longevity.

Explore More & Connect

You can read more about my engineering projects and web tools on my main portfolio:
👉 Visit Dipesh Sapkota's Portfolio
💻 Check out my code and repository archives on my GitHub Profile.

About the Author:
Dipesh Sapkota is a Computer Engineering student at IOE Thapathali Campus in Nepal, an AI/ML enthusiast, and a maker bridging embedded hardware systems with full-stack software development. Connect with him on LinkedIn.

As a Computer Engineering student at IOE Thapathali Campus, I am constantly exploring how to bridge the gap between robust software architecture and lightning-fast user interfaces. When handling live content and real-time data feeds, performance and reliability are everything.

To solve the friction of tracking multiple live matches across different platforms, I designed and developed Sportivo, a high-performance live sports streaming web application built for seamless match discovery and playback.

The Problem Sportivo Solves

If you are a sports enthusiast trying to follow live football, cricket, or basketball fixtures, you are usually met with cluttered streaming sites, intrusive ads, and broken links.

I wanted to build a clean, distraction-free platform focused on three core pillars:

• Real-Time Match Scraping: Aggregating fixtures dynamically so users can instantly find ongoing or upcoming events.

• Multi-Server Stream Switching: Providing fallback video sources and server toggles to ensure uninterrupted playback.

• Instant Match Search: Allowing users to filter streams instantly without page reloads.

Core Architecture & Tech Stack

To keep the application blazing fast and responsive, I built Sportivo using a modern web stack:

• Frontend Architecture: Developed using React and Vite, ensuring optimal client-side rendering speed and modular component design.

• Styling & UI: Designed with Tailwind CSS to maintain a sleek, modern dark-mode interface with zero layout shifts.

• Performance & Deployment: Hosted seamlessly on Vercel with custom domain routing (sportivo.dipeshsapkota7.com.np), leveraging edge caching for rapid global delivery.

Key Takeaways from the Build

• Graceful Error Handling & Fallbacks: Implementing a multi-server switching mechanism taught me a lot about handling unreliable video streams and network dropouts gracefully.

• Modular State Management: Keeping UI filters and search queries reactive required clean component state design to maintain a zero-latency experience.

Try It Out & Connect

You can test out the live platform directly here: 👉 Launch Sportivo Live Hub
💻 Explore the open-source repository and source code on my GitHub Profile.

About the Author:
Dipesh Sapkota is a Computer Engineering student at IOE Thapathali Campus in Nepal, an AI/ML enthusiast, and a digital creator specializing in software development and media arts. Explore his main portfolio at dipeshsapkota7.com.np or connect with him on LinkedIn.

To solve this—and to create a practical tool for fellow developers—I built and deployed Git Visualizer, an interactive, visually driven web application designed to break down Git workflows into intuitive, real-time visual states.

Why Build a Visualizer?

Most beginners hit a roadblock when they run into merge conflicts or accidentally mess up their commit history because text-based tutorials don't show the geometry of the branching tree.

I wanted to build something lightweight, highly responsive, and interactive that gives immediate visual feedback for standard operations like:

• git commit and staging workflows

• Branch creation and switching (git checkout / git switch)

• Merging branches and handling history divergence

• Resolving common stash issues (git stash and git stash pop)

Core Architecture & Tech Stack

For this project, I focused on clean component architecture and smooth state rendering using React, Vite, and Tailwind CSS.

• State Management for Commit Trees: The app tracks nodes (commits) and pointers (HEAD, main, feature branches) as a dynamic data structure. Every time a command is executed in the UI, state reducers recalculate node positions and update the rendering canvas.

• Performance & Deployment: Hosted seamlessly on Vercel with lightning-fast client-side routing, ensuring zero latency when stepping through command simulations.

Key Takeaways from the Build

Building this tool reinforced several crucial lessons in web architecture:

• State Immutability: Managing branching histories requires immutable state updates so that parent-child relationships between commits never break unexpectedly.

• UI/UX Clarity: Keeping animations minimal and purposeful ensures that users focus on what the command is doing to the branch structure rather than getting distracted by heavy graphics.

Try It Out & Connect

You can interact with the live tool directly here: 👉 Explore Git Visualizer
💻 Check out the repository and source code on my GitHub Profile.

About the Author:
Dipesh Sapkota is a Computer Engineering student at IOE Thapathali Campus in Nepal, an AI/ML enthusiast, and a digital creator specializing in technical software development and media arts. Explore his main portfolio at dipeshsapkota7.com.np or connect with him on LinkedIn.