REST APIs, queues, jobs, events, and business logic that stays maintainable.
Laravel • APIs • SaaS Systems • Vue.js
I build backend systems that let serious products ship faster, run cleaner, and scale without drama.
I bring 8+ years of hands-on engineering across SaaS, ERP, and operations-heavy products, with a focus on API design, queue-driven workflows, performance tuning, and dependable release pipelines that hold up in production.
- 8+ years delivering production software
- API-first architecture for SaaS and ERP platforms
- CI/CD delivery pipelines with release ownership
Clear communication, practical architecture, and execution you can rely on.
Scalability
Reliable queues
Database tuning
Frontend handoff
Business logic clarity
About
Backend engineering with strong ownership and zero unnecessary complexity.
My approach is simple: build for real traffic, keep the codebase understandable, and make delivery predictable for the team. That means solid architecture, well-defined APIs, optimized database access, resilient async processing, and close collaboration across product, frontend, and QA.
Architecture that stays practical
I design service boundaries and code structure around real business flows, so teams can extend features confidently instead of fighting technical debt.
Performance where it matters
From query plans to queue throughput and response times, I optimize where users feel speed and teams feel operational stability.
Full-stack when needed
My Vue.js experience helps me partner effectively with frontend engineers, shaping APIs that are both developer-friendly and production-safe.
Core strengths
Laravel, REST APIs, queue-based processing, SaaS and ERP domains, inventory and order workflows, third-party integrations, GitHub Actions, release pipelines, and ongoing production support.
Scalable APIs
Async processing
CI/CD delivery
Consulting ownership
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 backend work across SaaS, ERP, and operations-heavy systems.
These projects reflect the work I am usually trusted with: designing reliable systems, untangling complex domain logic, and helping teams scale 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
5/16/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 backend execution and calm problem-solving under pressure.
A few qualities teams consistently highlight after working together.