REST APIs, queues, jobs, events, and business logic that stays maintainable.
Open Source • Laravel • React • iOS • Android
Engineering Team Lead Leading engineering delivery from architecture to production while staying hands-on in Laravel and backend systems.
I help teams build backend systems with a product mindset, reduce release friction, and lead AWS production deployments across backend and platform initiatives.
Currently leading cross-platform engineering
AWS Production Deployment
Open source contributor
- Leadership Guiding teams and technical direction
- Architecture Backend systems, APIs, and platform design
- Delivery Production support and release ownership
Clear communication, practical architecture, and execution you can rely on.
Module Scaffolding, reusable backend patterns, and community-focused tooling.
About
Engineering leadership grounded in hands-on backend delivery.
I help teams build backend systems and lead engineering delivery across planning, architecture, execution, and production support. I mentor developers, shape technical decisions, and support product teams while remaining active in Laravel, PHP, REST APIs, and cross-functional delivery.
Guide engineering delivery
I help teams move with clear priorities, practical execution, and steady ownership from roadmap to production.
Shape backend architecture
I help define API boundaries, system structure, and reusable platform patterns that keep delivery sustainable.
Mentor developer growth
I support team members through code reviews, pairing, and practical feedback that improves quality and confidence.
Keep building backend systems
I remain active in hands-on Laravel and PHP development so I can lead from a place of direct technical experience.
Core strengths
Laravel, PHP, backend architecture, system design, team leadership, mentoring, code reviews, CI/CD, AWS, and production delivery.
Technical leadership
Architecture
Mentoring
Delivery
Career timeline
Progress from senior backend engineering to team leadership.
A clear path that combines production Laravel delivery with architecture ownership and technical leadership.
Senior Backend Engineer
Built reliable Laravel APIs, backend services, and delivery practices that supported product growth.
Backend Architecture
Helped shape platform structure, reusable backend patterns, and system boundaries for scale.
Cross-platform delivery
Led backend delivery across Laravel, React, iOS, and Android while aligning engineering work with product goals.
Engineering Team Lead
Own technical direction, mentoring, and production delivery while staying directly involved in the code.
Engineering Leadership
Leading delivery with technical depth, practical judgment, and steady ownership.
My role now includes guiding teams through architecture choices, planning, execution, and production reliability while staying close to implementation.
Technical Leadership
Providing clear direction, sound prioritisation, and reliable execution across engineering work.
Architecture & System Design
Shaping scalable backend foundations, API boundaries, and platform decisions that hold up over time.
Code Reviews
Raising quality, consistency, and engineering standards through thoughtful technical feedback.
Team Mentoring
Supporting developer growth through pairing, feedback, and practical guidance.
Sprint Planning
Turning product goals into realistic delivery plans that balance scope, risk, and execution.
Production Deployments
Supporting releases with operational awareness, reliability, and post-deployment care.
Cross-team Collaboration
Working closely with product, design, QA, and stakeholders to keep delivery aligned.
Engineering Best Practices
Improving CI/CD, testing habits, documentation, and maintainable engineering standards.
Recent Highlights
Recent milestones that reflect my current role and focus.
These are the kinds of responsibilities I am increasingly trusted with: leading delivery, strengthening engineering processes, and staying close to the technical work that matters.
Promoted to Engineering Team Lead
Taking on broader ownership across delivery, architecture, and team support.
AWS EC2 and production deployment
Successfully managed server setup, deployment readiness, and production rollout work.
Leading Laravel, React, iOS, and Android
Contributing across backend and cross-platform delivery as a technical lead.
Building internal engineering processes
Strengthening collaboration, review habits, and execution practices inside the team.
Continuing hands-on backend work
Still actively building Laravel systems while guiding the wider engineering effort.
Clients & Product Spaces
Hands-on delivery across products where backend quality is business-critical.
I have worked on platforms where downtime is expensive, logic errors hurt operations, and release quality directly affects customers and internal teams.
SaaS Platforms
ERP Systems
Inventory Solutions
Ordering Workflows
Multi-role Applications
Consulting Engagements
Production APIs
DevOps Pipelines
Projects
Selected work spanning backend architecture, delivery leadership, and production systems.
These projects reflect a combination of hands-on engineering and technical ownership: building reliable systems, improving execution, and helping teams ship with confidence.
Laravel Bootstrap CLI – Automated Local Development Environment Setup
A productivity-focused command-line tool that automates the entire Laravel project setup workflow on Linux systems. Designed to eliminate repetitive manual configuration, this tool streamlines the process of setting up a professional, nginx-based local development environment with a single command. The CLI handles all critical setup steps automatically: Laravel project creation, PHP-FPM configuration with version selection, MySQL database initialisation, local domain registration, SSL certificate generation (via mkcert), nginx vhost configuration, and environment file setup. Developers can spin up a fully configured Laravel project in minutes instead of spending 30+ minutes on manual configuration. With sensible defaults, flexible CLI options, and clear documentation, this tool reflects a real-world development workflow and is particularly valuable for developers working on multiple Laravel projects simultaneously.
Tech Stack
BashShell ScriptingnginxPHP-FPMMySQL
Stars
18
Updated
5/16/2026
Repository
Challenge
Automation Complexity Challenge: Orchestrating multiple system-level operations (DNS, nginx config, SSL generation, database creation) in a reliable sequence Solution: Built modular bash functions with error handling and validation at each step, with clear separation of concerns Cross-Version PHP Support Challenge: Supporting multiple PHP versions while correctly routing to the appropriate PHP-FPM socket Solution: Implemented dynamic PHP-FPM socket detection based on the selected version, with validation to ensure the version exists on the system Permission Management Challenge: Handling file and directory permissions correctly for nginx and PHP-FPM to avoid permission-denied errors Solution: Implemented automatic permission fixing for Laravel directories and proper ownership assignment during setup Nginx Configuration Challenge: Generating nginx vhost configurations programmatically that are compatible with Laravel and HTTPS Solution: Created template-based vhost generation with proper socket paths, SSL directives, and Laravel-specific location blocks SSL Certificate Generation Challenge: Providing trusted local SSL certificates without manual intervention Solution: Integrated mkcert support with fallback graceful handling if not installed Bash Script Clarity Challenge: Keeping a complex bash script maintainable and understandable Solution: Extensively documented code with clear comments, logical function organisation, and helpful error messages Features Highlights One-Command Setup: Eliminates 10+ manual steps with a single command Smart Defaults: Sensible configuration options reduce required input Flexible Configuration: CLI arguments allow customisation of project name, domain, and PHP version Sudo Privilege Handling: Prompts once for sudo access instead of repeatedly Browser Integration: Automatically opens the newly created project in the default browser Real-World Environment: Uses nginx + PHP-FPM + MySQL, matching production-like setups
Human vs Bot Chess Engine – A Full-Stack Architecture Project
A fully handwritten chess application that showcases custom architecture and game logic implementation. This project demonstrates full-stack development with a separation of concerns between a Laravel-powered backend handling all chess rules and bot strategy, and a Vue 3 frontend providing an interactive board interface. The application allows users to play chess against a locally running bot opponent, with the ability to choose their colour. The backend implements comprehensive chess rule validation (check, checkmate, stalemate, castling, en passant, and pawn promotion), while the frontend provides a responsive click-to-move interface with move history tracking. Currently in Phase 2, the project includes a captured pieces display and a material evaluation bar, with future phases planned for advanced bot strategy improvements. Key Achievement: All game logic and bot algorithms were written from scratch without relying on AI-generated code, showcasing genuine problem-solving and architectural design skills. Current Status Phase 2 Released – Includes captured pieces display and material evaluation bar Phase 1 & 3 – In progress with upcoming enhancements to bot strategy including: Strategy-aware evaluation incorporating center control, mobility, king safety, and pawn structure Enhanced bot move selection with deeper lookahead capabilities What Makes This Project Stand Out Custom Architecture: Every line of chess logic is handwritten, demonstrating genuine understanding of game mechanics Full-Stack Implementation: Combines a powerful PHP/Laravel backend with a modern Vue 3 frontend Iterative Development: Structured in phases, showing roadmap thinking and planned improvements Clean Separation of Concerns: Clear API contracts between frontend and backend for maintainability
Tech Stack
PHPLaravel 13Vue 3ViteBladeCSSTypeScriptMySQL
Stars
3
Updated
5/16/2026
Repository
Challenge
Chess Rule Implementation Challenge: Implementing complex chess rules correctly (castling conditions, en passant timing, check detection) Solution: Built robust validation logic on the backend to ensure game state integrity, with comprehensive move validation before execution Bot Move Generation Challenge: Creating an intelligent bot that makes reasonable moves without external libraries Solution: Implemented material-aware one-ply search algorithm with positional evaluation, with plans for deeper lookahead and multi-factor evaluation in future phases Frontend-Backend Communication Challenge: Maintaining game state synchronization between Vue frontend and Laravel API Solution: Designed RESTful API endpoints for game creation, move submission, history retrieval, and game reset Game State Persistence Challenge: Properly tracking game history and allowing resets Solution: Leveraged Laravel's ORM and migrations for reliable database management
Laravel Module Scaffolding – Domain-Driven CRUD Generator Package
A production-ready Composer package that automates end-to-end CRUD module generation for Laravel applications following domain-driven design principles. Born from frustration with existing scaffolding tools that didn't match real-world architectural preferences, this package generates complete, opinionated modules reflecting a clean, maintainable architecture. The generator creates full module stacks in seconds—from database migrations and models through controllers, services, query classes, validation layers, Blade views, and class-based JavaScript files—all organised under a domain-oriented namespace structure. Unlike generic scaffolders, it respects your architectural conventions: Spatie Data DTOs as direct method parameters (eliminating FormRequest boilerplate), explicit column selection in query classes for performance, class-based JavaScript modules stored as organised resources, and a cohesive layered architecture pattern. Active Project: This is a living tool continuously refined based on real-world usage in long-running production applications, with planned expansions for multiple architectural patterns to serve diverse developer preferences.
Tech Stack
PHP 8.2+Laravel 10/11/12/13ComposerArtisan CommandsBladeSpatie DataYAML
Stars
3
Updated
6/21/2026
Repository
Challenge
Opinionated Yet Flexible Architecture Challenge: Creating a generator that enforces good architectural practices without being overly rigid or one-size-fits-all Solution: Built configuration-driven stubs with a publishable override system, allowing developers to customise templates while maintaining core conventions (DDD structure, service layer pattern, query objects) Multiple Validation Strategies Challenge: Supporting both FormRequest and Spatie Data DTO validation approaches without code duplication Solution: Implemented validation abstraction layer with switchable stub generation, allowing DTOs to be passed directly as method arguments (your preferred pattern) Flexible Data Source Resolution Challenge: Accommodating multiple field definition methods (existing tables, YAML definitions, interactive prompts) without complex logic Solution: Implemented priority-based resolution strategy: existing schema → YAML file → interactive prompts, giving developers a choice while maintaining sensible defaults JavaScript Module Organisation Challenge: Generating class-based JavaScript modules that integrate seamlessly with Vite compilation and production minification Solution: Generated JavaScript files as organised class-based modules stored in the resources folder with Vite configuration compatibility for centralised compilation via app.blade.php Cross-Version Compatibility Challenge: Supporting Laravel 10, 11, 12, and 13 with different feature sets and API changes Solution: Abstracted version-specific behaviour through configuration and tested against all supported versions with CI pipeline validation Stub Customisation Without Maintenance Burden Challenge: Allowing developers to customise code generation while maintaining package upgradability Solution: Implemented a publishable stub system where only modified stubs are used; unmodified stubs fall back to package defaults Query Performance and Explicitness Challenge: Preventing N+1 queries and forcing developers to think about data access patterns Solution: Generated Query classes with explicit column selection enforcement (configurable), making data access intentions clear in the codebase
food
A food delivery system built for a local village, aimed at making it easy for customers to browse food options and place orders, while giving admins/vendors a simple dashboard to manage menus and track incoming orders. The project is heavily Blade-driven (server-rendered UI) and follows the classic marketplace flow: catalogue/menu → cart/order → order management on the backend. Because it was one of your earliest large projects, a big part of the work was establishing a clear architecture and separating responsibilities (ordering, restaurant/menu management, customer flows, and admin operations).
Tech Stack
PHPLaravel 8BladeJavaScriptLaravel MixAxiosLodashPostCSSLaravel PassportGuzzleHTTPdoctrine/dbalintervention/imagegrimzy/laravel-mysql-spatialbrian2694/laravel-toastrTwilio SDKNexmo/Vonage (nexmo/laravel)Stripe (stripe/stripe-php)PayPal (paypal/rest-api-sdk-php)Razorpay (razorpay/razorpay)MercadoPago (mercadopago/dx-php)Paystack (unicodeveloper/laravel-paystack)Flutterwave/Rave (kingflamez/laravelrave)PHPUnitLaravel SailSB Admin 2 (Bootstrap admin template)
Stars
0
Updated
4/14/2022
Repository
Challenge
Defining the architecture early: deciding how to structure the core modules (restaurants/menus, customers, cart/checkout, orders, admin panel) so the project could grow without becoming tangled. Modelling the order lifecycle: designing states and transitions (placed → accepted/preparing → dispatched → delivered/cancelled) and keeping UI + backend in sync. Payment + notifications complexity: integrating payment gateways and handling real-world concerns like confirmations, failures, and user messaging/alerts. Managing operational roles: separating permissions and experiences for customers vs admins/vendors/delivery (auth + authorisation + dashboards). Keeping the UI maintainable: a Blade-heavy app tends to accumulate duplicated markup—creating reusable layouts/components is key as pages increase.
Book Keeping
A Laravel-based book‑keeping web app focused on building a clean, UI-heavy experience for tracking and managing records. The project uses Vite for a modern frontend workflow, with a strong emphasis on custom styling and frontend structure (CSS/SCSS making up the majority of the codebase). It’s designed as a practical full‑stack app where the backend handles application structure and data flow, while the frontend delivers a polished, responsive interface.
Tech Stack
LaravelPHP 8.3Vitelaravel-vite-pluginTailwind CSS@tailwindcss/viteAxios@vitejs/plugin-basic-sslConcurrentlyspatie/laravel-dataPestPHPUnitLarastanPHPStanLaravel PintRectorEasy Coding Standard (ECS)
Stars
0
Updated
5/24/2026
Repository
Challenge
Defining a maintainable CSS architecture for a UI-heavy app (keeping styles scalable and avoiding “CSS sprawl”). Integrating and managing static/vendor assets alongside the Vite build (copying/build output and keeping public assets in sync). Keeping frontend build tooling stable while iterating quickly (safe builds, local dev ergonomics, and predictable outputs). Maintaining code quality and consistency across a mixed stack (PHP + JS + CSS/SCSS). Ensuring the project stays upgrade-friendly over time (Laravel + Vite + dependencies).
Laravel Vite Starter
Laravel Vite Starter Kit is a ready-to-use template repository for bootstrapping new Laravel applications with a modern frontend workflow powered by Vite. It’s intended to remove the repetitive setup work you do at the start of every project—so you can clone the repo and immediately begin building features instead of configuring tooling. The starter kit pairs a standard Laravel project structure with a Vite-based asset pipeline (including Tailwind CSS) for fast local development, optimised production builds, and a smoother full-stack development experience. It also includes a curated set of developer tooling and scripts to support day-to-day productivity (setup, development, testing, and code quality checks), making it a solid baseline for personal projects, prototypes, and production-ready applications. In short: it’s a clean Laravel foundation with Vite + modern frontend tooling already wired up, designed for rapid project starts and consistent developer experience.
Tech Stack
PHP 8.3LaravelVitelaravel-vite-pluginTailwind CSS@tailwindcss/viteAxiosConcurrentlyPestPHPUnitLaravel PintRector (driftingly/rector-laravel)PHPStanEasy Coding Standard (ECS)
Stars
0
Updated
4/10/2026
Repository
Challenge
Locking the scope early: defining what “starter kit” should (and should not) include so it stays lightweight, reusable, and doesn’t become a full opinionated app. Future-proofing the template: choosing a setup that can evolve without painful rewrites as Laravel, Vite, and frontend tooling change. Dependency upgrade strategy: keeping dependencies easy to upgrade by avoiding unnecessary coupling, sticking to standard conventions, and relying on widely adopted packages. Balancing defaults vs flexibility: providing sensible out-of-the-box scripts and tooling while keeping the project easy to customize per use case.
Shreedhan Treadlink
A lightweight service-management web app built to help a recharge shop track customer recharges and avoid missed expiry dates. The initial scope focused on recording recharge details and highlighting when a recharge is about to end, then expanded into a broader set of shop services (e.g., SIM porting and related requests). The project is UI-driven (CSS-heavy) and built as a Laravel application with a simple JavaScript layer for interactivity and Vite for asset bundling.
Tech Stack
PHPLaravel 9Laravel SanctumVitelaravel-vite-pluginJavaScriptAxiosLodashPostCSSyajra/laravel-datatables-oraclePHPUnitLaravel PintLaravel SailGuzzleHTTP
Stars
0
Updated
2/22/2025
Repository
Challenge
Starting with a single, clear problem (recharge expiry tracking) and then evolving the scope without turning the project into an unmaintainable “everything app”. Designing data structures/workflows that support multiple service types (recharges, SIM port, etc.) while keeping the UI and forms consistent. Building a UI-heavy app where most of the work lives in styling and layout, keeping CSS organized and reusable as screens/features grow. Integrating a modern asset pipeline (Vite) into a Laravel app and keeping build/dev workflows smooth. Handling real-world usability details (quick entry, search/filtering, and clear status indicators for “ending soon” vs “active/expired”).
Ami Enterprise
A back-office management system built for a lighting wholesale business to centralise day-to-day operations in one place. The app covers employee management, purchases, orders, partial payments, payment follow-ups, and internal employee task/notes—providing a single workflow for tracking outstanding amounts, operational activity, and team execution. It’s implemented as a Laravel + Blade application, optimised for form-heavy CRUD flows and admin-style dashboards.
Tech Stack
PHPLaravel 8BladeLaravel SanctumJavaScriptLaravel MixAxiosLodashPostCSSyajra/laravel-datatablesGuzzleHTTPPHPUnitLaravel Sail
Stars
0
Updated
2/22/2025
Repository
Challenge
Translating real-world business processes into simple, usable workflows (purchases → orders → partial payments → follow-ups). Designing a flexible data model for payments (tracking partials, outstanding balances, payment history, and follow-up status without inconsistencies). Keeping admin UI complexity manageable as modules grow (employees, tasks/notes, orders, purchases, payments). Ensuring data integrity across interconnected entities (e.g., orders linked to customers, payments linked to orders, follow-ups linked to outstanding balances). Building a maintainable Blade-based UI for a feature-rich dashboard while keeping screens consistent and easy to navigate.
Shibam
An older Laravel + Blade project that appears to be an admin-style CRUD application with an informative/site-content component. Based on the codebase composition (heavy JavaScript and CSS) and common patterns in the dependencies, it’s structured like a dashboard where content/records can be created, updated, listed, and managed through tables and forms—focused on delivering a functional interface with a lot of front-end customization.
Tech Stack
PHPLaravel 8BladeJavaScriptLaravel MixAxiosLodashPostCSSyajra/laravel-datatables-oracleLaravel SanctumGuzzleHTTPPHPUnitLaravel SailCSSLessSCSS
Stars
0
Updated
2/22/2025
Repository
Challenge
Building and maintaining a UI-heavy dashboard (layout consistency, reusable components, and keeping styles manageable as pages grow). Implementing “classic CRUD” flows in a way that stays user-friendly at scale (searching, sorting, pagination, bulk actions). Keeping data tables performant and usable (especially when datasets grow and the UI relies on table-based views). Coordinating a mixed stack (PHP/Blade + JavaScript + CSS/Less/SCSS) and keeping the asset pipeline predictable. Ensuring long-term maintainability in an older Laravel/Mix setup (dependency drift and upgrading constraints over time).
Hot Focus
A “basic social media” platform prototype built with Laravel, focused on core community features and real-time interaction. The project explores typical social app building blocks—user accounts, content posting, and interactive workflows—using a server-rendered Blade UI, plus realtime capabilities (WebSockets) to make parts of the experience feel live (e.g., notifications/chat-style updates). In retrospect, the main functional gap is that it doesn’t include the kinds of growth/monetisation mechanics real social platforms need—like an advertisement layer and interest tracking/personalisation for feeds—so it remains a strong foundational prototype rather than a complete product-ready social network.
Tech Stack
PHPLaravel 8BladeLaravel Sanctumbeyondcode/laravel-websocketslaravel-echoPusher (pusher/pusher-php-serverpusher-js)Vue 3vue-loaderJavaScriptLaravel MixAxiosLodashPostCSSyajra/laravel-datatablesGuzzleHTTPPHPUnitDockerDockerfileShellLaravel Sail
Stars
0
Updated
2/22/2025
Repository
Challenge
Designing the “social graph” domain: users, posts, relationships/interactions, and the data model behind timelines/feeds. Implementing real-time features reliably (WebSockets/events), including local development complexity and state synchronisation. Preventing common social-app edge cases: authorisation rules, privacy boundaries, content ownership, and moderation-style constraints. Keeping performance reasonable for feed-like pages (avoiding N+1 queries, keeping queries/indexing sane as datasets grow). Recognising what’s required beyond CRUD for a real social platform (ads, interest tracking, ranking, analytics) and making tradeoffs on scope.
Testimonials
Trusted for dependable delivery, technical judgment, and calm leadership under pressure.
A few qualities teams consistently highlight after working together.