Software development services

Website development

Any kind of website, built by an engineer rather than a template — business sites, landing pages, online stores and web apps. Fast, responsive, SEO-ready, and yours to own.

• Business & company websites
• Landing & marketing pages
• E-commerce stores
• Web applications & portals
• Redesigns & rebuilds
• Hosting, deployment & SEO setup

Backend & API development

Server-side systems built on ASP.NET Core — the engine behind a booking flow, a marketplace, or an internal tool. Built for correctness under load, not just for a demo.

• Clean-architecture Web APIs
• JWT / OAuth authentication
• Background jobs & schedulers
• Logging, monitoring & error tracking
• Multi-tenant / role-based access
• Legacy .NET Framework upgrades

Frontend & dashboards

Interfaces for the people who use the system every day — internal teams, customers, or admins. Built to stay fast as the data grows, not just at demo scale.

• React single-page applications
• Admin & operations dashboards
• Data-heavy tables, filters, exports
• Real-time updates (SignalR)
• Responsive, accessible UI
• Design-to-code implementation

Database engineering

The layer everything else depends on. Schema design and query performance done right the first time, or fixed when an existing database is buckling under real traffic.

• Schema & relationship design
• Stored procedures & triggers
• Query tuning & indexing
• Migration planning (zero-downtime)
• Reporting & analytics queries
• Database health audits

Shopify store design, apps & admin

The whole Shopify build from one engineer — a store designed and built to sell, plus the custom apps, admin panels and integrations that themes alone can't do.

• Store design, build & redesign
• Theme customization (Liquid)
• Custom admin panels & internal tools
• Private & public Shopify apps
• Admin API & Storefront API integration
• Order, inventory & fulfillment automation

Third-party & system integrations

Getting two systems that were never meant to talk to each other to actually work together reliably — payments, bookings, supplier feeds, or internal services.

• Payment gateway integration
• Booking / reservation engine integrations
• Supplier & GDS API connections
• Webhook pipelines & event handling
• REST, SOAP & gRPC services
• Data sync between systems

Booking engine development

My flagship build, already shipped: a live multi-GDS travel platform. Flight, hotel, tour and appointment booking with real-time search, payments, refunds, supplier integration and an admin panel your team can run.

• Flight & hotel booking (GDS)
• Multi-supplier aggregation & failover
• Tours, activities & appointment booking
• Payment, price-hold & refund logic
• Markup, commission & multi-currency rules
• Operations admin panel & audit logs

B2B & B2C travel portals

Travel portals wired straight into Amadeus, Sabre and Travelport. A B2B portal for your agent network or a B2C site for travellers — live flight & hotel search, agent wallets, markup, payments and an admin panel. Built on a live multi-GDS platform.

• B2B agent portals with wallets & markup
• B2C flight & hotel booking sites
• Amadeus / Sabre / Travelport GDS integration
• Hotel & supplier API aggregation
• White-label / multi-brand portals
• Payments, refunds & multi-currency

Deployment & ongoing support

Software is never really "done" — it's maintained. Ongoing coverage for systems already in production, plus the deployment work to get a new one live safely.

• CI/CD pipeline setup
• Performance & security audits
• Bug fixes & feature additions
• Server & hosting configuration
• Monthly support retainers
• On-call for critical issues

Azure cloud & DevOps

The work between "it runs on my machine" and "it's live, stable and monitored." Deploying .NET and web apps to Azure, with one-click releases and the monitoring that keeps them healthy.

• App Service & container deployment
• CI/CD pipelines (GitHub Actions / Azure DevOps)
• Azure SQL, storage & Key Vault
• Application Insights & alerts
• Staging / production separation
• Cost right-sizing & scaling

AI integration

AI wired into your real product — a chatbot that answers from your own data, a feature that drafts or summarises, a workflow that stops needing a human for the boring part. The OpenAI and Claude APIs, integrated reliably.

• OpenAI & Claude API integration
• Chatbots & internal assistants
• Retrieval over your own data (RAG)
• Document processing & extraction
• Workflow automation
• Cost controls, guardrails & fallbacks

Mobile apps

A mobile app for iOS and Android from a single React Native codebase — not two native builds at twice the cost. And because I build the backend too, it runs on the same API your website already uses.

• iOS & Android from one codebase
• Connected to your existing backend
• Login, secure sessions & biometrics
• Offline support & sync
• Push notifications
• App Store & Play Store submission

Power BI & reporting

You already have the data — you just can't see it. Power BI dashboards that pull it together, model it correctly, and show the numbers that drive decisions, refreshed automatically. Built right at the source, because I build the databases too.

• Executive & operational dashboards
• Data models & DAX measures
• Connections to SQL Server, Excel & APIs
• Automated scheduled refresh
• Row-level security
• Performance tuning for large data

Payment & API integrations

The part of a build where "mostly works" isn't good enough. Payment gateways and system-to-system integrations, built idempotent and reconciled — the same way money flows in my live booking platform.

• Stripe, PayPal & Razorpay integration
• Webhooks with retries & deduplication
• Refunds & reconciliation
• ERP / CRM / third-party API connections
• Idempotent, auditable money operations
• Sandbox testing before going live

Fixed-scope projects

For a clearly defined deliverable — a website, a Shopify app, a booking flow, a specific integration. We agree the scope, price and timeline in advance, so you know exactly what you're getting and what it costs before anything begins. Payment is milestone-based, released stage by stage as work is delivered and approved — never a large sum upfront.

Monthly retainers

For ongoing work that doesn't fit a single deliverable — a steady stream of features, maintenance, performance work and support on a system already in production. You get a predictable monthly cost and a developer who already knows your codebase, instead of re-explaining it to someone new every time something needs doing.

Audits & rescue work

For an existing system that's slow, unstable or half-finished. I start with a paid audit — a clear, honest report on what's wrong and what it takes to fix it — before committing to changes. That way you get an independent read on the state of things first, with no obligation to continue.

• You own 100% of the source code — handed over in full, no lock-in
• Clean, documented code any developer can pick up later
• A written scope, price and timeline agreed before work starts
• Milestone-based payments — never a large sum upfront
• Previews as the work progresses, so nothing is a surprise at the end
• Testing on real scenarios, not just the happy path
• A proper handover with docs, plus a support window after launch
• Direct contact with the engineer doing the work — no account managers