Full-stack developer.
Custom systems builder.
I build custom software for businesses that have outgrown generic tools — using Laravel, Django, WhatsApp API, and AI. Based in London, working with clients across the UK, UAE, Saudi Arabia, and elsewhere.
I started out building front ends. The work that kept me up at night was never what users saw — it was the stuff behind the screen: the workflow bottlenecks, the repetitive tasks no one had time for, the integrations that broke whenever something changed.
These days I build software for companies that have outgrown spreadsheets and off-the-shelf tools — around how they actually work, not around what a product lets them do.
From building screens to solving operations.
My growth did not come from stacking frameworks. It came from working inside real products — seeing fragile workflows, client pressure, and manual processes that broke down under daily use.
I build custom web applications, booking platforms, internal tools, CRM-style systems, and WhatsApp-driven automation for businesses that need software designed around how they actually operate — not adapted to fit a generic product.
Leap Interactive, Dubai
Joined as an intern. Worked on MagicTap as a front-end developer — first exposure to a real, client-facing product under pressure.
TechSpark
Multiple clients, multiple problems. I realised the bottleneck was never missing features — it was always a broken workflow underneath.
Back to MagicTap
Returned as a full-stack developer with broader responsibility. Took the platform from fragile to scalable — 80% fewer bugs, 6 weeks.
Custom systems
Every project since has pointed the same way: businesses need software built around their workflow, not the other way around.
The story behind the systems I build now
Started in front-end in Dubai, ended up building full custom software — business automation, CRM-style platforms, WhatsApp API integrations, booking engines, internal tools — for businesses that needed something built around how their team actually works, not a product they had to adapt to.
First real job was at Leap Interactive in Dubai, as an intern on MagicTap. Front-end work, client calls, the usual early-career combination of figuring things out while they're watching. That was where I learned products don't behave the way they do in a browser — clients break them in ways no one planned for.
After Leap I moved to TechSpark, juggling several client projects at once. Appointment systems, bug fixes, maintenance on things already in production. The useful part wasn't any one project — it was stepping into messy systems mid-flight, figuring out how the business actually ran, and making things more reliable without breaking what already worked.
Leap called me back to own MagicTap properly, this time as full-stack developer. Spent that chapter fixing the architecture, cutting down the instability, and pushing the platform toward something that could actually scale. The lesson from that one: a codebase can get cleaner and still fail if the underlying business model depends on things the software can't control.
In parallel I built Xpense Diary — a WhatsApp expense tracker using Django, Gemini, and the WhatsApp API directly. That project was the turning point for how I work. Until then I'd been leaning on abstraction layers for everything; building Xpense Diary convinced me to work with APIs directly instead of through someone else's wrapper.
The pattern that showed up in every project after that: most businesses get offered the same software bundled the same way, even when their day-to-day is completely different from whoever designed it. That's why I focus now on custom software, workflow automation, and internal tools built around how a specific company operates — not around what a SaaS product happens to support.
I stopped seeing software as pages and started seeing it as workflow.
The biggest shift was learning to look at the process first — where time is wasted, where teams repeat manual work, and where disconnected tools create daily friction.
Software that fits how your team works, not the other way around.
Custom software, CRM systems, booking platforms, WhatsApp automations, AI tools for internal workflows — built around how a business actually runs, not around what a SaaS product lets it do.
The businesses I can actually help
This is the kind of work that tends to fit: a business has outgrown spreadsheets and needs something built around how they operate — custom software, workflow automation, a CRM-style internal tool, or a system built for their process rather than adapted from a generic platform.
Good fit
- Businesses that have outgrown spreadsheets and manual tracking.
- Teams that need a custom CRM or internal tool built around their actual workflow.
- Operations-heavy businesses doing repetitive manual work every day.
- Clinics, service businesses, agencies — anyone needing a booking or appointment system that actually handles their edge cases.
- Businesses that want WhatsApp automation without going through a third-party platform.
- Companies that need internal tools powered by AI for their team.
Problems I usually solve
- Disconnected tools that don't talk to each other.
- Manual follow-ups, repetitive admin work, and workflow gaps that waste time daily.
- Rigid SaaS software that forces the team to adapt to the product, not the other way around.
- Internal processes that need structure, visibility, and some automation.
- Custom web application needs that off-the-shelf software genuinely can't handle.
What guides the way I build
Six principles I come back to on every project — because good software is as much about decisions as it is about code.
Workflow first
I start with the process, not the feature list. The workflow tells you what actually needs building — everything else is guesswork.
Custom over bloated
Tighter systems built around real requirements outlast generic platforms you adapt with workarounds.
Ownership matters
A business should control its workflows and tools, not rent them from a vendor indefinitely.
Architecture is strategy
Scale, dependencies, and business fit are architectural decisions — not something you bolt on after the fact.
Automation should feel natural
The best systems cut manual effort without creating new friction for the team using them.
Clarity over noise
Clear outcomes, useful systems, and direct communication — every time.
The tools behind the work
Laravel and Django form the backbone of every custom software system I build — from CRM-style platforms and booking engines to workflow automation and WhatsApp API integrations. Around that I work with databases, infrastructure, deployment, and frontend tooling to deliver systems that hold up in real daily use.
Need a system built around your workflow?
I work with businesses that need custom software, cleaner operations, better automation, and tools designed around how their team actually works — not adapted from a generic platform.