Portfolio Project
Tavolo · Booking platform
Restaurant booking platform. Discovery, live availability and a floor-aware dashboard for restaurants.
- Laravel
- PHP
- MySQL
- REST API
Full Stack Developer
I build software that works beyond the demo.
Full Stack Developer with 12+ years of experience turning complex business requirements into scalable web applications, modern interfaces, reliable APIs and AI-powered solutions.
projects/page.tsx
1export async function getProjects() {2 const res = await api.get("/projects")3 return res.data.map(toCard)4}56export default function Page() {7 return <Grid items={projects} />8}
Years of Experience
Building production web apps
Full Stack Engineering
Laravel, React, Vue.js, Node.js, Next.js
AI-Powered Development
LLM features in real products
Commitment
Clear scope, honest updates
Development journey
I've spent 12+ years learning that good software isn't about writing more code.
From PHP pages to AI-powered engineering, the tools changed every few years. The questions underneath them mostly did not.
2014
Foundation
PHP, MySQL and WordPress sites for small businesses. This is where I learned that a working page and a maintainable system are different things.
I started with PHP and MySQL, building WordPress sites and small custom applications. Back then, “it works on my machine” was a perfectly good definition of done. It took a few production incidents to change that.
2016
Backend Engineering
Laravel became the default. Designing schemas, writing APIs other developers had to live with, and finding out what happens when data grows.
2019
Full Stack Development
React and Next.js on the front, Node.js where it fit. API-driven applications where the interface and the backend are designed together.
Laravel taught me structure. React and Next.js taught me that an interface is part of the system, not a coat of paint on top of it. Node.js showed up wherever real-time or JavaScript-everywhere made sense.
2022
Architecture & Scale
Integrations between systems that were never meant to talk to each other, deployment and infrastructure, and performance work that starts with measuring.
Over time the interesting work moved away from individual screens. It became APIs that other teams depend on, databases that have to stay correct, integrations between systems that were never designed to meet, and the architecture that holds all of it together.
2025+
AI-Powered Engineering
AI in my daily workflow and, increasingly, inside the products I build. Faster iteration, with the same review discipline.
Now AI is part of that picture. I use it every day to move faster, and I build it into products where it earns its place. The judgement about what to build, and what to leave out, is still the job.
Expertise
Six areas, one connected picture.
Each discipline matters on its own. The value is in how they fit together.
Backend Architecture
Services that stay understandable as requirements change.
- Laravel
- PHP
- Node.js
- Express
- REST APIs
- Authentication
- Queues
- Jobs
- 3rd-party tool Integrations
Frontend Engineering
Interfaces that are fast, accessible and easy to extend.
- React
- Vue.js
- Next.js
- TypeScript
- Tailwind CSS
- State Management
- Component Architecture
- Performance
Database Engineering
Schemas and queries designed for the data you will have next year.
- MySQL
- PostgreSQL
- MongoDB
- Sequelize
- Schema Design
- Relationships
- Query Optimization
- Synchronization
API & Integration Engineering
Connecting systems so that the data stays correct.
- Axios
- WooCommerce
- WordPress
- Payment integrations
- Business systems
- Data synchronization
Infrastructure
Deployments that are boring, repeatable and secure.
- Linux
- Apache
- DigitalOcean
- Git
- Docker
- AWS
- Deployment
- SSL
- Production environments
AI Engineering
AI as a development tool and as a product capability.
- Claude
- ChatGPT
- AI-assisted development
- LLM integrations
- AI workflows
- Automation
How I work
Ask better questions. Build on principles. Ship with care.
Most problems arrive half-described, so I start with questions, lean on a few steady principles while I build, and treat speed and safety as part of the job, not a last-week patch.
06
questions before I write code
Slowing down at the start is the cheapest speed-up there is.
- 1
What problem are we actually solving?
The request is rarely the problem. I want to understand the situation behind it first.
- 2
What happens when the application grows?
More users, more data, more developers. Cheap to consider now, expensive to retrofit.
- 3
Can the architecture explain itself?
If a new developer needs a meeting to understand the structure, the structure is the problem.
- 4
Where can complexity be removed?
The best feature is often the one we decide not to build, or build in a simpler way.
- 5
What happens when something fails?
Networks drop, third parties go down, inputs are wrong. Failure paths are part of the design.
- 6
Will another developer understand this six months from now?
That developer is often me. Clear names, small units and honest comments pay for themselves.
08
principles I keep coming back to
Simple to read, safe to change, and kind to whoever opens the code next.
Simplicity
The simplest design that solves the real problem. Every extra moving part has a cost.
Maintainability
Code is read far more often than it is written. I write for the next reader.
Performance
Speed is part of the experience. I measure before and after, and I don't guess.
Security
Validate at the boundary, keep secrets on the server and assume input is hostile.
Scalability
Scale when there's a reason, but make choices today that don't block it tomorrow.
Accessibility
Keyboard, screen reader and low-vision users are users. It's built in, not bolted on.
Observability
If you can't see what the system is doing, you can't fix it at 3am.
User Experience
Clear, fast and forgiving. The technology should disappear.
Lighthouse targets
Lighthouse targets for this site. Not claimed as achieved until measured.
90+
Performance
95+
Accessibility
95+
Best Practices
95+
SEO
Performance
Fast isn't a feature. It's part of the experience.
Performance is designed in from the first component, not patched in before launch.
- Server rendering by default
- Static generation where appropriate
- Image optimisation
- AVIF / WebP
- Lazy loading
- Code splitting
- Font optimisation
- Minimal JavaScript
- Transform and opacity animation
- Core Web Vitals focus
- Caching strategy
- Responsive images
Security
Secure by habit, not as an afterthought.
This site is a static-first frontend, but the same habits apply to every application I build.
- No secrets in client-side code
- Environment variables for configuration
- CSP-ready architecture
- Safe external links
- Dependency hygiene
- XSS awareness
- Form validation on client and server
- Secure future API integration
- Authentication-ready structure
AI development
AI changed how I develop. It didn't replace how I think.
AI makes me faster. Experience tells me where to go. I use it as a capable assistant and review everything it produces as I would a colleague's pull request.
Code generation
Boilerplate, scaffolds and first drafts, reviewed and reshaped.
Debugging
A second pair of eyes on stack traces and unexpected behaviour.
Documentation
Readable docs and comments drafted from the code itself.
Refactoring
Safer, smaller steps with the intent stated up front.
Research
Faster comparison of libraries, patterns and trade-offs.
Testing
Test cases and edge conditions I might have missed.
Architecture exploration
Pressure-testing an approach before committing to it.
Developer productivity
Less time on repetitive work, more on design decisions.
Global
Building for businesses without borders.
Built to work with founders, teams and businesses across time zones and markets: clear communication, careful handling of data, and software ready for regional variants.
Time-zone friendly
Overlap where it matters, async updates everywhere else, so work keeps moving across the UK, UAE, Europe, USA and Australia.
Written-first communication
Clear specs, decisions and status notes, so nobody waits on a call to know what happens next.
Privacy and compliance aware
Data handling, consent and accessibility considered from the first sketch, not retrofitted before launch.
Ready for regional variants
Language, currency, dates and content structured so a new market is configuration, not a rebuild.
Featured Projects
Products built to show how I approach real problems.
Products I designed and built to show architecture and craft.
Portfolio Project
Cadence Kitchen · Subscription SaaS
Meal-plan subscription platform with skip, pause and nutrition tracking.
- React.js
- TypeScript
- React Query
- Node.js
Portfolio Project
CareBridge · Web application
Clinic portal with appointments, records and role-based access for five user types.
- React.js
- Laravel
- PHP
- MySQL
- 12+
Years of Experience
Building production web apps
Full Stack Expertise
Laravel, React, Vue.js, Node.js, Next.js
Security First
Validated input, secrets on the server
Transparent Process
Clear scope and honest updates
Performance Focused
Core Web Vitals in mind
AI-Powered Builds
LLM features in real products