What I built, how it was run, and how I work with you
Six real projects, from a 3-year enterprise engagement to sites that went live in 7 hours. Below you will find what each one involved, how we worked with the client, who did what, and a transparent way to estimate your own project.
A superannuation member website on AEM Edge Delivery Services, delivered in 3 months with a steady weekly rhythm of client calls.
NGS Super needed a fast, accessible website that its own team could update without developers. AEM EDS was the platform: lightweight pages, easy authoring, and a header that stays in step with the site as pages change.
3 monthsstart to live
AEM EDSblocks and authoring setup
Dynamicnavigation that updates itself
RESTAPI integrations in blocks
My role: AEM EDS developer: blocks, authoring, navigation and API integration
What I built
Authoring components (AEM EDS blocks)
I designed and built a library of reusable blocks, each with a simple authoring structure that editors fill in. Content teams assemble pages from these blocks, so most new pages need no developer at all. Each block is responsive, accessible and checked against Lighthouse.
Dynamic navigation
The header menu is generated from the site's own page structure. When pages are added, renamed or moved, the header updates automatically, with no code change and no redeploy. That removes a whole class of 'we forgot to update the menu' problems.
Client API integration
The client provided the APIs, and I connected them to blocks so live data appears on authored pages, with proper loading and error states so a slow or failing API never breaks the page.
Platform setup and go-live
EDS configuration, performance and accessibility checks, and a go-live checklist, so the launch was calm and predictable.
Google Analytics
I added Google Analytics to the site, so the team can measure traffic and see how members find and use their pages.
How we worked
Call 1: requirement gatheringEvery week we walked through the next set of pages and components, confirmed content and API needs, and agreed priorities.
Build between callsI built the blocks and pages, tested them, and shared a preview link so the client could see real progress, not slides.
Call 2: feedback and bugsLater the same week we reviewed the preview together, logged feedback and bugs, and agreed exactly what would be fixed next.
Repeat, then launchRepeating this loop through the project kept surprises small. At the end the site went live.
A 3-year engagement on a large insurance website with 1000+ pages and 100+ API calls, built with AEM components and React features powered by Redux.
Tata AIA runs one of India's large insurance sites: over a thousand pages, many product and fund pages, and customer features that depend on live data. The work was to keep that platform fast, consistent and easy for authors to extend while adding real functionality.
3 yearsof continuous delivery
1000+pages on the site
100+API calls integrated
Reduxfor predictable state
My role: Frontend developer: AEM components, React features and Redux state
What I built
Authoring components in AEM
I built AEM components with author-friendly dialogs, HTL (Sightly) templates and client libraries, so content teams can assemble and maintain 1000+ pages from consistent building blocks instead of one-off pages.
Interactive features in React
Functionality that needs real interaction was built as React components inside AEM pages: fund information, contact-us forms, and flows for updating a customer's email address or mobile number, each with validation and clear feedback.
State management with Redux
Redux holds the shared state: form data across steps, user details, API responses and loading/error status. Components stay small and predictable, which matters when one feature touches many APIs.
API integration at scale
More than 100 API calls power funds data, contact requests, customer detail updates and more. I structured them behind a consistent integration layer with validation and error handling, so adding the next API is routine instead of risky.
Quality in production
Code reviews, browser debugging, accessibility checks and production troubleshooting kept a large, always-live site stable across releases.
Google Analytics
Google Analytics is integrated across the site, including the React-driven journeys, so the business can measure traffic and understand how visitors use its pages and features.
How we worked
Agile, in sprintsWork was planned in sprints with the wider team: requirements refined, tasks estimated and delivered in regular releases.
Components firstShared AEM components and React building blocks were built once and reused across pages and features.
Review and releaseEvery change went through code review and testing before release, with production support afterwards.
The client provided
Business requirements and product rules
API specifications and environments
Page structure and content from the authoring teams
I delivered
AEM components, templates and dialogs
React feature development
Redux store design and state flows
API integration and validation
Debugging, performance and accessibility
Google Analytics setup
03
AEM + React · General and health insurance (India)
A 2-year AEM and React engagement on an insurance website, built around close API discussions, careful functionality logic and a steady flow of change requests.
An insurer's website is more than pages: products, renewals, claims and customer journeys all depend on APIs and business rules that keep changing. The work was to build and maintain that functionality reliably while the business kept evolving it.
2 yearsof continuous delivery
AEM + Reactauthoring plus interactive features
API talksagreed with the client's teams
Change requestshandled as the business evolved
My role: Frontend developer: AEM components, React features, API integration and change requests
What I built
Authoring components in AEM
I built AEM components with author-friendly dialogs and templates, so content teams can create and update pages from consistent building blocks without developer help.
Functionality in React
Interactive journeys were built as React components inside AEM pages, with the validation, states and feedback users expect from a modern insurance site.
API discussions and integration
Before building, I worked through each API with the client's teams: what is requested, what comes back, which errors can occur. Then I integrated it with clear loading and error handling, so the feature behaves well when a service is slow or fails.
Functionality logic
I translated business rules into code, asking the right questions up front so edge cases were settled in conversation instead of found in production.
Change requests
Requirements changed over two years. Each change request was understood, estimated, implemented, tested and released, keeping the codebase tidy so the next change stayed cheap.
Google Analytics
I added Google Analytics tracking to the site, including the React-driven journeys, so the team can measure traffic and understand how customers use the pages.
How we worked
Discuss the API and the logicFor each feature we agreed the API contract and the business rules with the client before any code was written.
Build and reviewComponents and integrations were built, code reviewed and tested against the agreed behaviour.
Change request cycleNew or changed requirements followed a simple loop: clarify, estimate, implement, test, release.
A complete online store built end to end in 9 days: storefront, admin dashboard, database, image storage and a large application integration.
A food brand needed to sell online quickly, with its own admin and no ongoing platform fees eating into margin. I built the whole stack: what customers see, what the team manages, and the data underneath.
9 daysfrom start to live
Full-stackstorefront + admin + DB
Databasemanaged Postgres in this build
Cloudimage storage
My role: Full-stack developer: design, storefront, admin, database and deployment
What I built
Storefront
A fast, premium-feeling shop: product browsing, search and cart, customer accounts, a membership programme, gifting, free-delivery messaging and a first-order offer, plus a WhatsApp shortcut for quick customer contact.
Admin dashboard
A private back-office for the team to manage products, images and orders without touching code, so everyday changes never need a developer.
Database and image storage
A database holds products, customers and orders (managed Postgres in this build), and product images are uploaded from the admin to cloud storage and served fast to shoppers. The exact tools can change to suit each client's requirements.
Large application integration
The store connects to a larger application, so data and processes flow between systems instead of being re-entered by hand.
Google Analytics
Google Analytics is set up on the store, so the owner can see traffic and how shoppers use the site, and make decisions from real data.
How we worked
Days 1 to 2: foundationsData model, project setup and the storefront skeleton, so everything after builds on solid ground.
Days 3 to 5: shopping experienceCatalogue, search, cart, accounts and offers.
Days 6 to 7: adminDashboard, product management and image upload.
Days 8 to 9: integrate, test, launchApplication integration, QA across devices, deployment and go-live.
The client provided
Brand identity and product details
Offers and business rules, such as the first-order gift and delivery threshold
A clear, trust-building website for a 24x7 water supply business, designed, built and live in about 7 hours.
A local service business needed a professional online presence that explains its services and makes it easy to request a delivery. The goal: live fast, look credible, work on every phone.
~7 hrsto build and go live
Responsiveworks on every device
Livedeployed and publicly available
Clear CTAsrequest supply, view services
My role: Frontend developer: design, build and deploy
What I built
Focused page structure
A strong hero with the offer and two clear actions, followed by services, areas served and contact, so a visitor understands the business in seconds.
Responsive, fast and simple
Mobile-first layout with lightweight assets, so it loads quickly on phones and mid-range connections.
Deployed live
Deployed live and ready to connect to a custom domain whenever the business wants.
How we worked
Brief to structureAgree the services, areas and main call to action.
Design and buildLayout, copy placement and build in one focused session.
DeployTest on mobile and desktop, then publish live.
The client provided
Business details, services and areas covered
Logo and any photos
I delivered
Page structure and visual design
Responsive frontend build
Testing and deployment
06
Frontend website · International shipping and logistics
A corporate website for an international logistics company, designed, built and live in about 7 hours.
A shipping company needed a clean corporate site that communicates reliability: what it does, how it works and how to get in touch, with a design that feels established.
My role: Frontend developer: design, build and deploy
What I built
Corporate site structure
Home, About, Services, Core Business and Contact, with a clear headline and call to action up front.
Brand-led visual design
Imagery, colour and typography that match the company's logo and industry.
Deployed live
Deployed live, with a custom domain easy to add later.
How we worked
Brief to structureAgree sections, tone and the main action.
Design and buildLayout and build in a single focused session.
DeployResponsive testing, then live.
The client provided
Company details and service descriptions
Logo and brand colours
I delivered
Page structure and visual design
Responsive frontend build
Testing and deployment
How I work
Know what to expect before we start
Prices are negotiable and shared after a short call about your project. You can choose a fixed price or hourly billing. The estimate below depends on four things, and it is calibrated on projects I have actually delivered: two sites in about 7 hours each, a full store in 9 days, and a 3-month AEM EDS build.
5+years of experience
6live projects
3 yrson one enterprise engagement
100+API calls integrated
01
Functionality
Every feature (forms, admin, accounts, payments, integrations) adds a known amount of effort.
02
Complexity
Simple, standard or complex scopes change the effort, because unknowns and integrations take longer.
03
What you provide
Ready designs, content and fast feedback reduce the effort. If I create them, they are added.
04
What I do
Design, build, test, deploy and hand over. You see the scope in writing before work starts.
1 What are you building?
Up to about 10 pages, contact form, SEO basics and smooth interactions. Built on the same approach as the quick-build sites, with more pages and polish.
2 Which functionality do you need?
3 How complex is it?
4 What can you provide?
Design
Content and images
Feedback speed
What I need from you
A short written brief, or a 30-minute call to walk me through the goal
Designs, brand assets and content (or tell me to create them, see above)
Access to anything I must integrate: APIs, documentation, test credentials
One point of contact who can approve work quickly
What I do for you
Plan the scope and timeline, and confirm them before I start
Design (if needed), build, test, connect the database and host the site
Make it responsive, accessible and fast, checked with Lighthouse
Share previews regularly and fix the feedback you give
Hand over clearly, with the go-live checklist done
How a project runs
01
Discovery call
We talk through your idea or goals, your customers and any existing systems, so I understand what success looks like for you.
02
Scope in writing
I confirm what will be built, what you provide and what I do, and send a written estimate for your approval.
03
Build with previews
I build in stages and share preview links, with regular check-ins for feedback and bug discussions.
04
Database, hosting and launch
I connect the database, host the site, and test across devices with performance, accessibility and go-live checks before it goes live.
05
Support after launch
Once the site is live I can fix issues and handle updates, so it keeps running well.
My promises to you
01
Scope and estimate in writing
Before I start, you get the scope, the estimate and the timeline in writing, so there are no surprises later.
02
Updates you can actually see
Preview links and regular check-ins, the same rhythm that worked on NGS Super, with two client calls every week.
03
Changes handled openly
If requirements change, I explain the effect on time and cost first, and go ahead only when you agree.
04
Fast and performance-minded
Pages are checked with Lighthouse and for accessibility before launch. Two brochure sites went live in about 7 hours each.
05
A clean handover
A tested site with the database connected and hosting set up, plus a go-live checklist, with code organised so your team or another developer can carry on.
06
Business-first advice
Whether you come with an idea or a goal, I focus on what helps your business most, and I will always suggest the option that fits best.
Common questions
I look at four things: the functionality you need, how complex it is, what you can provide (designs, content, quick feedback) and what I need to do. The estimate is based on projects I have actually delivered. After a short call I confirm the scope and send a final quote.
Either. A fixed price suits a clear scope, and hourly billing suits work that will keep evolving. Prices are negotiable, and we agree the approach before I start.
Yes. I work as a developer and a consultant. You can come with a clear idea and I will build it, or come with a goal and we will work out together what the website should do. I look at how your business works and what your customers need, then share practical ideas, and we decide together what is worth doing.
Absolutely. Share your requirements and designs, or let me design it, and I will build it end to end, including the database and hosting.
Yes. I work end to end: after building, I connect the database and host the site, so it goes live ready to use. Tell me what your project needs and I will set up what suits it.
That is normal. We follow a simple loop: clarify the change, estimate its effect, agree, then build, test and release. I handled change requests like this for two years on an insurance website.
A short brief or a call is enough. Designs and content are helpful, or I can create them. If anything needs connecting, such as an API, I will need access and documentation. One person who can approve work quickly makes everything faster.
Yes, that is a main goal. With AEM EDS I build reusable blocks and set up authoring with the Universal Editor, and for online stores I build an admin dashboard, so routine updates do not need a developer.
Yes. For example, I delivered the NGS Super website for an Australian client, with two calls every week and preview links in between.
Yes. I have migrated sites to AEM EDS and worked alongside client teams on enterprise sites, using regular calls, previews and code reviews.
Yes. I have supported live sites in production, fixing issues and handling updates. We agree the support arrangement upfront.
It depends on scope. A brochure website took about 7 hours of work, a full online store took 9 days, and a large AEM EDS build took a few months with weekly client calls. After a short call I give you a clear plan for your scope.
Have a project in mind?
Let's bring it to life and give it its own small space on the internet. Share a few details and I'll reply with next steps.
