Process
Clear steps. Useful checkpoints. No mystery work.
Every engagement starts with context and a shared definition of success. Scope, deliverables and timelines are agreed before implementation.
Stage 01
Discover
Goals, audiences, current tools, constraints and success indicators.
The question What problem are we solving, for whom, and how will we know it worked?
What happens
- Goals and audience conversation
- Review of current site, tools and data
- Constraints: budget, timing, approvals, languages
You'll have
- Shared problem statement
- Known constraints and risks
- Approval before moving on
- You confirm the problem statement and what success looks like.
- What we need from you
- Access to current tools and one person who can make decisions.
- Risk it reduces
- Building the wrong thing well.
Stage 02
Define
Proposed scope, content, integrations, risks and a prioritized plan.
The question What is the smallest useful scope — and what is deliberately out?
What happens
- Written scope with in/out list
- Integration and content dependencies
- Prioritised plan with review points
You'll have
- Written scope
- Prioritized plan
- Approval before moving on
- You sign off the written scope before any build starts.
- What we need from you
- Decisions on priorities, existing content and integration access.
- Risk it reduces
- Scope creep and surprise costs.
Stage 03
Design
Wireframes, visual direction, key interactions and bilingual layout needs.
The question Does the direction work for real people, in both languages?
What happens
- Wireframes for key pages and flows
- Visual direction applied to real content
- Arabic RTL and mobile layouts checked early
You'll have
- Approved direction
- Key screens and flows
- Approval before moving on
- You approve the direction and key flows.
- What we need from you
- Feedback from the people who will use or sell with it.
- Risk it reduces
- Late redesigns once code exists.
Stage 04
Build
Small slices with working previews and review points.
The question Is each slice working as agreed?
What happens
- Small slices on preview links
- Integrations built against test data
- Change log of what moved and why
You'll have
- Working previews
- Regular review points
- Approval before moving on
- You review each working preview before the next slice.
- What we need from you
- Timely review of previews; real content where needed.
- Risk it reduces
- A big-bang reveal that misses the brief.
Stage 05
Verify
Browser, responsive, accessibility, performance, form and SEO checks.
The question What has actually been checked — and what hasn't?
What happens
- Browser, device and accessibility checks
- Form and integration tests end-to-end
- Performance and SEO checks on a production build
You'll have
- Check results
- Resolved launch blockers
- Approval before moving on
- Launch blockers are resolved or explicitly accepted by you.
- What we need from you
- Final content approval and launch timing.
- Risk it reduces
- Launching with broken forms or inaccessible pages.
Stage 06
Improve
Handover, measurement and a prioritized next-iteration backlog.
The question What did we learn, and what should change next?
What happens
- Handover documentation
- Measurement against the success signals from Discover
- Prioritised next-iteration backlog
You'll have
- Documentation
- Next-iteration backlog
- Approval before moving on
- You choose what goes into the next iteration — if anything.
- What we need from you
- Access to analytics and feedback after launch.
- Risk it reduces
- A site that is never improved after launch day.
What you can expect from us
Visible trade-offs
When there's a choice to make, you'll see the options and what each one costs.
Working previews
You review real, working pages and flows — not just static images.
Plain reporting
We report what was checked and what wasn't. “Tested” means tested.
Ready for something that works beyond the demo?
Tell us what you want to achieve. We'll use it to make the first conversation genuinely useful.