DEV Community: Dipesh Sapkota

Building an IoT Emergency Response System with ESP32

Dipesh Sapkota — Thu, 01 Oct 2026 17:37:57 +0000

As a Computer Engineering student at IOE Thapathali Campus, my work bridges embedded hardware systems with digital logic. While browser software solves critical problems on screen, engineering hardware that interacts with physical environments brings a completely different challenge.

For this project, I engineered an IoT-Based Emergency Response System for the Elderly, powered by an ESP32 microcontroller, integrated motion/biometric sensors, and a custom-fabricated printed circuit board (PCB).

The Problem

Traditional personal emergency alarms often rely on manual SOS buttons. In acute medical crises or sudden falls, an individual may lose consciousness or physical mobility, rendering manual triggers useless.

This system addresses that gap with:

Automated Anomaly Detection: Continuous polling of motion modules to detect abrupt impacts and posture changes.
Instant Wi-Fi Telemetry: The dual-core ESP32 triggers emergency alerts over local Wi-Fi without relying on a paired smartphone.
Hardware Stability: A custom-designed PCB layout ensures stable power delivery and debounces sensor noise.

Hardware Stack & Architecture

Core MCU: ESP32 (chosen for built-in Wi-Fi, dual-core architecture, and low-power sleep modes).
Sensor Layer: Motion and biopotential modules capturing real-time telemetry.
Firmware: Written in C++, implementing asynchronous interrupt routines and non-blocking network calls for low-latency alert dispatching.
PCB Design: Schematics designed and verified through circuit simulation tools prior to physical milling and soldering.

Key Engineering Takeaways

Hardware Debouncing & Noise Filtering: Raw sensor output on microcontrollers requires software filtering and hardware capacitance decoupling to avoid false alarm triggers.
Power Plane Routing: Routing ground planes cleanly on custom PCBs proved critical to avoiding signal crosstalk between Wi-Fi transmission bursts and sensitive analog inputs.

Connect & Explore More

🌐 Portfolio: dipeshsapkota7.com.np
💻 GitHub Archive: dszae

About the Author:

Dipesh Sapkota is a Computer Engineering student at IOE Thapathali in Nepal, an AI/ML enthusiast, and a Video Editor & Motion Graphics Designer. Connect with him on LinkedIn or visit his Portfolio.

Building an Interactive Git Visualizer to Master Version Control

Dipesh Sapkota — Thu, 01 Oct 2026 17:37:42 +0000

Git is fundamental to modern development, yet commands like git rebase, git merge, and git checkout remain abstract and confusing for beginners. Traditional explanations rely on static branch diagrams that fail to convey how snapshots and pointer references actually move through the workspace.

To solve this, I designed and developed Git Visualizer — an interactive web tool built with React that translates abstract Git commands into real-time visual state trees.

Why Visualizing Git Matters

Developers often treat Git like an opaque terminal spellbook rather than a directed acyclic graph (DAG) of snapshots. Common friction points include:

Confusing the Working Directory, Staging Area (Index), and Local Repository.
Misunderstanding how HEAD moves during checkouts versus commits.
Fear of branch merge conflicts and fast-forward rebases.

How Git Visualizer Works

Dynamic Graph Rendering: Every commit operation dynamically updates an SVG-based node tree representing commits, branch pointers, and HEAD.
Step-by-Step Command Playback: Users run simulated Git operations (commit, branch, checkout, merge) and observe pointer transitions step-by-step.
Interactive Hover Telemetry: Inspect any commit node to inspect commit hashes, parent references, and staged changes.

Engineering Challenges

Graph Layout Mechanics: Dynamically calculating branch lane offsets and commit parents so tree branches render cleanly without line collisions.
State Machine for Git Operations: Implementing an internal state machine that accurately reproduces standard Git tree logic within a client-side React state store.

Live Demo & Source Code

🌐 Live Web App: Git Visualizer
💻 GitHub Repository: dszae/git-visualizer

About the Author:

Dipesh Sapkota is a Computer Engineering student at IOE Thapathali in Nepal, an AI/ML enthusiast, and a Video Editor & Motion Graphics Designer. Explore his portfolio at dipeshsapkota7.com.np or connect on GitHub.

Building Sportivo: How I Engineered a Live Sports Streaming Web App

Dipesh Sapkota — Thu, 01 Oct 2026 17:37:13 +0000

Live sports streaming platforms often suffer from cluttered interfaces, broken video players, and clunky navigation. As a developer, I wanted to build a lean, distraction-free web application that aggregates real-time sports fixtures and delivers seamless playback across multiple broadcast sources.

That project became Sportivo — a responsive live streaming web app built with React, Vite, and Tailwind CSS.

The Problem

Most sports streaming aggregators present a poor user experience:

Ad overload & slow UI: Finding a match link usually requires navigating through layers of disruptive popups.
Dead stream links: Single-source embeds frequently crash mid-match.
Messy navigation: Cluttered fixture lists make it difficult to locate games across football, cricket, and basketball quickly.

Architecture & Core Features

Real-Time Schedule Scraping: Matches and timings are dynamically fetched and categorized by sport.
Multi-Server Stream Switching: Users can toggle between backup video servers directly inside the player container without reloading the page.
Instant Filter & Search: Client-side fuzzy searching lets users filter by team, league, or sport in milliseconds.
Direct Share Links: Every fixture generates a unique query string so users can share match links directly.

Key Technical Takeaways

Embedding & Responsive Video Wrappers: Handling iframe and HLS/m3u8 video containers responsively while preventing intrusive third-party frame redirects required strict sandbox policies.
State Management for Multi-Stream Failover: Designed an intuitive server selector that preserves playback position and fallback states when an active server disconnects.

Live Demo & Source Code

🌐 Live Application: Sportivo
💻 GitHub Repository: dszae/sportivo

Launching My Digital Portfolio: Bridging Code & Creative Media

Dipesh Sapkota — Sat, 12 Sep 2026 03:54:33 +0000

I’m excited to officially launch my new digital portfolio—a central hub where my background in Computer Engineering intersects with my passion for visual media and AI/ML technologies. 🚀

Over the last few months, I’ve focused on building tools designed to solve concrete problems and simplify complex workflows. My new site highlights my latest technical builds:

🎓 IOE Admission Hub: A comprehensive analytics toolkit for Tribhuvan University engineering applicants, featuring statistical rank predictions and automated priority form generation.
🌿 Git Visualizer: An interactive, visually driven learning tool designed to demystify version control through live, dynamic data-flow mapping.

The portfolio is built from the ground up using React, Vite, and Tailwind CSS, featuring a custom interactive canvas engine and a strict focus on performance optimization.

Check out the live site and explore the projects here: https://www.dipeshsapkota7.com.np/

I’d love to hear your thoughts or feedback on the interactive elements!

ComputerEngineering #WebDevelopment #ReactJS #SoftwareEngineering #PortfolioLaunch #TechNepal #UIUX #DeveloperCommunity