top

● Selected work

Projects

A deck of things I've built — scroll to lift through it, one card at a time.

01 / 05Live

Maedot Pharmacy

Transforming Pharmacy Operations: A Solo Endeavor This project represents a solo build for a real client, currently active in production. It began with absolutely no prior digital infrastructure, requiring a complete, ground-up architectural solution. The Client Reality Before this system, the pharmacy operated with a purely paper-based inventory. This led to significant challenges: expired stock often went unnoticed, leading to waste, and the administrative overhead of manual tracking consumed hours daily. Imagine the constant risk of stockouts and the sheer manual effort involved in managing patient records and prescriptions without a digital backbone. 💡 Architecting a system solo where real patients depend on the outcome demands a profound sense of responsibility and meticulous attention to detail at every stage. The System Inventory Engine At the core of the inventory management is a robust engine leveraging atomic operations within Prisma. This is crucial for handling concurrent stock mutations. By using atomic operations, we prevent race conditions where multiple requests attempting to update the same stock item simultaneously could lead to inconsistent or incorrect inventory counts. This ensures data integrity even under heavy load. Stock Alert System To combat stockouts, a SKU-level threshold monitoring system was implemented. When a stock level hits its predefined threshold, a real-time alert is pushed via WebSockets directly to the relevant user role (e.g., inventory manager). WebSockets were chosen over traditional polling because they provide immediate, bidirectional communication, ensuring that staff are notified the instant a critical stock level is reached, rather than relying on periodic checks. Expiration Tracking A batch-level schema was designed to meticulously track expiration dates. A scheduled job runs regularly to identify and flag items nearing expiration. Since the implementation of this feature, the pharmacy has experienced near-zero losses due to expired stock, significantly improving profitability and reducing waste. RBAC Layer A robust Role-Based Access Control (RBAC) layer is implemented at the middleware level. This ensures that permissions are strictly scoped for roles such as Pharmacist, Admin, and Doctor. A clearly bounded access surface prevents unauthorized access to sensitive patient data and system functions, mitigating risks associated with data breaches and internal misuse. Telemedicine + Stripe The system facilitates end-to-end payment capture through integration with Stripe. A WebSocket session layer manages the communication between the client and server during consultations and payment processes. Integrating Stripe involved handling secure tokenization, managing payment intents, and processing webhooks to confirm transactions accurately, ensuring a seamless and secure payment experience for patients. async function handlePayment(orderId: string, paymentIntentId: string) { // Verify payment intent status with Stripe const paymentIntent = await stripe.paymentIntents.retrieve(paymentIntentId); if (paymentIntent.status === 'succeeded') { // Update order status in DB using Prisma atomic operation await prisma.order.update({ where: { id: orderId }, data: { status: 'PAID', paymentDetails: { create: { stripeId: paymentIntentId, amount: paymentIntent.amount, currency: paymentIntent.currency, }, }, }, }); // Push notification via WebSocket sendWebSocketMessage(userId, 'payment_success', { orderId }); } else { // Handle payment failure sendWebSocketMessage(userId, 'payment_failed', { orderId }); } } This system has led to significant improvements, including an estimated ~60% overhead reduction in administrative tasks, ~45% fewer stockouts, and facilitated over 500 consultations. Staff now save approximately 4 hours per day previously spent on manual inventory and administrative duties. Closing The system is in production today. Real pharmacists. Real patients. Real operations.

programmingweb-developmente-pharmacy
View projectLive ↗
Maedot Pharmacy
02 / 05Live

Safaricom API Intelligence Dashboard — Enterprise Integration Monitor

API Intelligence Dashboard: A Deep Dive This dashboard provides critical insights into my application's API performance, highlighting the unique challenges and benefits of observability at the integration layer, which differs significantly from standard application monitoring by focusing on inter-service communication health. What It Monitors This API Intelligence Dashboard specifically tracks over 2,000+ daily API calls, providing real-time visibility into endpoint health states (live, degraded, down), per-service throughput, and the crucial split between database and cache traffic. This includes a detailed look at the ~73% cache hit rate. Endpoint Health Tracking The health state model is defined as follows: 'Live' indicates an endpoint is responding within acceptable latency and error thresholds. 'Degraded' signifies increased latency or a minor rise in error rates, suggesting potential issues. 'Down' means the endpoint is unresponsive or consistently returning critical errors. Maintaining visibility across these states is operationally vital for proactive issue resolution and service reliability. Cache vs DB Signal The split between database and cache traffic is a powerful indicator of system efficiency and potential bottlenecks. A high cache hit rate, like the observed ~73%, means a significant portion of requests are being served quickly from memory, reducing load on the primary database. A declining cache hit rate would immediately signal issues with cache performance or increased database strain, prompting an investigation into query performance or caching strategies. 💡 Monitoring an application is about its internal state, while monitoring the integration layer is about the health and performance of the communication pathways between services. Here's a simplified example of how I might log API request data using Node.js: interface ApiLogEntry { timestamp: Date; endpoint: string; method: 'GET' | 'POST' | 'PUT' | 'DELETE'; responseTimeMs: number; status: number; isFromCache: boolean; } function logApiRequest(entry: ApiLogEntry): void { // Logic to send this data to the dashboard backend console.log('Logging API request:', entry); } Closing This dashboard replaced fragmented logging and manual log parsing, enabling rapid identification of API performance issues and a clear understanding of inter-service dependencies.

programmingweb-developmenttelecom
View project
Safaricom API Intelligence Dashboard — Enterprise Integration Monitor
03 / 05Live

Safaricom Ethiopia — Official Site

My Contribution to Safaricom Ethiopia's Digital Platform A production contribution to one of the highest-traffic digital platforms in Ethiopia — not a demo, not a simulation. The Platform Safaricom Ethiopia's platform serves millions of users, enabling critical digital services. Shipping code to this environment requires adherence to rigorous standards and an understanding of the complexities inherent in an enterprise engineering workflow. Feature 1 — Event Display System I developed and integrated a new card-based event display system on the frontend, pulling data from a dedicated backend service. Owning both the frontend presentation logic in TypeScript and the backend API integration meant ensuring data consistency, efficient querying, and a seamless user experience. Event Display System - Backend Integration Example interface EventCardProps { id: string; title: string; date: string; location: string; } async function fetchEvents(): Promise<EventCardProps[]> { const response = await fetch('/api/v1/events'); if (!response.ok) { throw new Error('Failed to fetch events'); } return response.json(); } Feature 2 — Security Hardening Layer I architected and implemented a backend security layer designed to mitigate common web vulnerabilities. This included robust input validation to prevent injection attacks, strict authorization checks to block unauthorized access to sensitive data, and comprehensive data sanitization to prevent data leakage. The goal was to create a more resilient and secure API. Security Layer - Input Sanitization Example import { sanitize } from 'validator'; function processUserInput(input: string): string { // Basic sanitization to remove potentially harmful characters const sanitizedInput = sanitize(input, { allowedTags: [], allowedAttributes: {} }); return sanitizedInput; } 💡 Navigating a large, established codebase as a junior developer is an unparalleled opportunity for accelerated learning in best practices and architectural patterns. Closing My involvement in these critical areas provided direct experience with the challenges and rewards of developing for a live, high-impact platform.

web-developmenttelecom
View projectLive ↗
Safaricom Ethiopia — Official Site
04 / 05Live

Redat-Woreda Appointment Scheduler

Redat-Woreda: Revolutionizing Ethiopian Civic Appointments. As project lead and primary full-stack developer for Redat-Woreda, our senior capstone project, I spearheaded the creation of a digital appointment scheduling system designed to modernize a critical Ethiopian government service. This project addressed the real-world challenge of inefficient paper-based processes within a tight academic delivery timeline, demanding innovative solutions from our team. The Domain: Bridging the Digital Divide. A 'woreda' is an administrative district in Ethiopia, akin to a county or municipality. Woreda offices handle essential citizen services like ID processing and permit applications, traditionally managed through a cumbersome paper-based appointment system. A breakdown in this scheduling process, due to manual errors or lost paperwork, can cause significant delays and hardship for citizens needing these vital documents. Scheduling Core: Conflict-Aware Appointment Creation. At the heart of Redat-Woreda is a robust conflict-aware appointment creation mechanism. We leveraged MongoDB and Mongoose to define a data model that inherently prevents double-bookings. The Mongoose schema enforces uniqueness on a combination of the assigned staff member, start time, and end time, ensuring that no two appointments can occupy the same slot for a given staff member. const mongoose = require('mongoose'); 💡 The unique index on `assignedStaffId`, `startTime`, and `endTime` is crucial for preventing data integrity issues and ensuring accurate scheduling within the MongoDB database. Real-Time Queue: Instant Updates with WebSockets To provide an immediate and seamless experience, Redat-Woreda utilizes WebSockets for real-time queue updates. Unlike traditional polling methods, WebSockets allow for instant push notifications, meaning both citizens and staff see the most current appointment status without manual refreshes. This significantly reduces wait times and improves operational efficiency for the woreda office. 💡 WebSockets are ideal for applications requiring constant two-way communication, making them perfect for live updates in a busy appointment system. This capstone project successfully transitioned a critical civic service from manual processes to a functional, real-time digital platform. const appointmentSchema = new mongoose.Schema({\ citizenId: String, serviceType: String, startTime: Date endTime: Date, assignedStaffId: String }); appointmentSchema.index( { assignedStaffId: 1, startTime: 1, endTime: 1 }, { unique: true } );

programmingweb-development
View projectLive ↗
Redat-Woreda Appointment Scheduler
05 / 05Live

Cali Store — Full-Stack E-Commerce Platform

Cali Store: A Production-Grade E-commerce Platform This project, Cali Store, represents a fully realized, production-ready full-stack e-commerce platform designed for serious businesses. It's built from the ground up to handle the complexities of online retail, offering a robust solution for merchants looking to establish or enhance their digital storefront. What sets Cali Store apart is its technical depth, employing a modern, scalable stack to ensure performance and maintainability. Core Technologies and Architecture At its core, Cali Store leverages the power of Next.js with the App Router for a streamlined, server-centric application architecture. TypeScript provides static typing for enhanced developer experience and reduced runtime errors. Data persistence is handled by PostgreSQL, hosted on the high-performance Neon serverless platform, with Drizzle ORM offering a type-safe and efficient way to interact with the database. Client-side data fetching and state management are expertly managed by TanStack Query, ensuring a responsive user interface. 💡 This stack is chosen for its scalability, developer productivity, and production readiness, moving beyond typical tutorial project limitations. Key Features and Functionality Customer-facing storefront with dynamic product listings and user authentication. Comprehensive admin dashboard for product management, order fulfillment, and user oversight. Integrated Stripe for secure and reliable payment processing. Transactional email capabilities for order confirmations, shipping updates, and customer communication. Complete order lifecycle management, from placement to delivery. The platform is not merely a demonstration; it's a fully functional system capable of handling real-world transactions and business logic. The integration of Stripe ensures secure payment handling, while the transactional email system keeps customers informed at every stage of their purchase. This end-to-end implementation covers the entire customer journey and the necessary backend operations for a successful e-commerce business. Technical Rigor and Production Readiness Cali Store is engineered with production in mind. The choice of Next.js App Router facilitates optimized server rendering and efficient data fetching strategies. Drizzle ORM, with its focus on type safety and performance, minimizes the risk of database-related errors. TanStack Query ensures that the client application remains performant and responsive, even with complex data interactions. ⚠️ This project prioritizes real-world application over theoretical concepts, showcasing a robust and scalable e-commerce solution. Conclusion Cali Store stands as a testament to building production-grade applications with modern web technologies. It provides a complete, feature-rich e-commerce platform that is technically substantial and ready for deployment. This project demonstrates a deep understanding of full-stack development principles, database management, API integrations, and the intricacies of building a reliable online retail system.

programmingweb-developmentSSR
View projectLive ↗
Cali Store — Full-Stack E-Commerce Platform