Engineering
Specifications.
Deep-dives into distributed systems, database schema optimization, and low-latency infrastructure built for high-concurrency environments.
Uvidense Talent Marketplace
Lead Engineer / System Designer
A multi-currency talent marketplace engineered to support secure global hiring through escrow-backed transactions, structured booking workflows, and scalable API consumption.
Logical separation of business domains within a single codebase to maintain high developer velocity while ensuring strict boundaries between core services.
The marketplace requires high transactional consistency across bookings and payments. A modular monolith avoids the 'distributed monolith' trap, ensuring atomic database transactions while allowing modules to be extracted into microservices as traffic scales.
Enforced domain boundaries using internal Service Contracts to prevent spaghetti dependencies
Implemented a custom Escrow Ledger with ACID-compliant database transactions
Utilized asynchronous event listeners for non-blocking post-transaction tasks (notifications, analytics)
Standardized API responses using the JSON:API specification for frontend predictability
Issue #1
Synchronizing booking states across Client and Talent without race conditions.
FIX:Implemented a Finite State Machine (FSM) to govern transitions, backed by database-level row locking.
Issue #2
Performance degradation during complex multi-filter talent searches.
FIX:Normalized search schemas and moved heavy filtering to indexed database views.
- Eliminated N+1 issues via strict eager-loading policies in the data access layer
- Implemented composite indexing on high-traffic talent search queries
- Integrated Redis for caching profile metadata and localized currency rates
- Engineered a stateless API layer to facilitate seamless horizontal scaling via load balancing
- Separated read/write concerns for talent listings to reduce database contention
- Configured dedicated queue workers to handle high-latency background processes
Architecture should favor simplicity until scale demands complexity; a well-structured monolith is often superior to premature microservices.
Enterprise Management System (IBEDC)
Full-Stack Engineer
A unified command center for a power distribution company, integrating billing, meter management, and field incident tracking into a high-availability dashboard.
System architecture mapped directly to utility business units, ensuring technical logic mirrors operational reality.
Utility operations are naturally siloed but data-dependent. DDD allows the Billing and Metering domains to evolve independently while sharing a common language, preventing the system from becoming an unmanageable enterprise legacy 'big ball of mud'.
Mapped technical modules to 'Bounded Contexts' to ensure domain integrity
Designed a robust RBAC (Role-Based Access Control) system for sensitive financial data
Implemented a batch-processing engine for high-volume monthly billing cycles
Created a centralized logging system for auditability of field operator actions
Issue #1
Processing thousands of billing calculations concurrently without locking the database.
FIX:Implemented a job-chunking strategy and offloaded calculations to background workers with exponential backoff.
Issue #2
Maintaining data consistency between field reports and central billing.
FIX:Established an eventual consistency model using an internal message bus to sync updates.
- Optimized large-scale meter data ingestion using batch inserts and database triggers
- Reduced report generation time by 70% through materialized views and precomputed aggregates
- Implemented database sharding logic for historical incident logs
- Offloaded heavy reporting workloads to a dedicated read-replica database
- Utilized horizontal pod autoscaling for the API layer to handle peak billing cycles
- Containerized core services for consistent deployment across environments
Enterprise software must prioritize data integrity and auditability, ensuring that technical structures align with the organization’s operational flows.
Mahdumo SaaS LMS
Lead Engineer / Architect
A multi-tenant learning platform supporting thousands of learners with automated grading, content delivery, and institutional reporting.
A shared-application architecture with logical data isolation, optimizing resource usage while keeping tenant logic separated.
The SaaS model required low operational overhead for new tenant onboarding. A multi-tenant monolith allows for easy global updates and shared infrastructure costs, using middleware to ensure strict data isolation.
Implemented 'Shared Database, Isolated Schema' (or Scope-based) multi-tenancy
Engineered an automated Grading Engine with queue-based processing to handle high-concurrency exams
Designed a polymorphic asset storage system to handle varied course media
Built a tenant-aware middleware to prevent cross-tenant data leakage
Issue #1
Preventing 'noisy neighbor' issues where one tenant's heavy usage slows down others.
FIX:Implemented resource quotas and partitioned background queues based on tenant priority.
Issue #2
Maintaining high performance during simultaneous school-wide exams.
FIX:Utilized database connection pooling and optimized write-heavy grading endpoints.
- Applied global query scopes to all database calls for automatic tenant filtering
- Optimized gradebook queries using pivot table indexing
- Leveraged Content Delivery Networks (CDN) for low-latency video and asset delivery
- Separated tenant-facing APIs from internal administrative tools
- Designed the grading engine to scale horizontally via worker pools
- Implemented Redis-based rate limiting to protect system resources per tenant
Multi-tenancy is an exercise in isolation; the architecture must guarantee that data security is handled at the framework level, not the feature level.
IBMSSP Assessment Platform
Backend Engineer
A specialized engine for benchmarking organizational maturity through complex multi-dimensional scoring and comparative analytics.
A functional decomposition approach using 'Services' for business logic and 'Actions' for discrete, reusable operations.
The core complexity was mathematical rather than structural. The Service/Action pattern encapsulates the complex scoring algorithms into testable units without the overhead of microservices or heavy domain boundaries.
Decoupled heavy computation from HTTP controllers using the Action pattern
Implemented an immutable Audit Trail for all assessment changes to ensure compliance
Designed a flexible JSON-based assessment schema to support dynamic question types
Integrated a PDF generation pipeline for automated executive reporting
Issue #1
Managing the computational cost of real-time benchmarking against global datasets.
FIX:Introduced a pre-aggregation layer that updates benchmarks asynchronously.
Issue #2
Supporting deeply nested scoring logic that varied by industry.
FIX:Used the Strategy Pattern to swap scoring algorithms based on the assessment type.
- Developed an efficient recursive query structure for multi-level benchmarking
- Implemented results-caching to avoid re-calculating scores for static reports
- Utilized database views for complex cross-organizational comparisons
- Configured a distributed task runner for long-running report generation
- Separated the calculation-heavy scoring engine from the user-facing web layer
- Designed the API to be consumeable by multiple external auditing tools
When business logic is the primary bottleneck, architecture must prioritize code reusability and mathematical accuracy over infrastructure complexity.
CIMA – Social Safety Platform
Backend Engineer
A real-time safety ecosystem that leverages location data and social trust networks to provide emergency alerts and tracking.
Separation of tracking, security, and social logic, coordinated by a central event bus for real-time responsiveness.
The system handles high-frequency location pings and low-latency alerts. Separating the Geo-Tracking domain ensures that location updates don't block social interactions or identity management.
Utilized a Pub/Sub model for real-time alert distribution
Implemented Geo-fencing logic to trigger alerts based on user location
Designed a permission-based 'Trust Link' system for data privacy
Built an abstraction layer for multi-channel push notifications (FCM, APNS)
Issue #1
Maintaining sub-second alert delivery for emergency triggers.
FIX:Prioritized alert queues and bypassed non-essential middleware during emergency pings.
Issue #2
Protecting user privacy while allowing emergency access to location.
FIX:Implemented an 'Emergency State' flag that only reveals data to trusted contacts during active alerts.
- Optimized spatial queries using PostGIS for high-accuracy location tracking
- Implemented a TTL (Time-To-Live) strategy for temporary location logs to manage data growth
- Reduced notification latency by optimizing the alert delivery pipeline
- Scaled the Geo-Tracking module independently to handle high-frequency pings
- Used Redis Pub/Sub for low-latency communication between tracking workers
- Stateless session management to allow global distribution of API nodes
Real-time safety systems require a 'failure-is-not-an-option' mindset, demanding low latency and rock-solid security boundaries.
Available for
Technical Consultation.
Currently accepting complex engineering challenges involving distributed state, real-time data pipelines, and infrastructure automation.
Review Codebase