Skip to main content

A practical guide to building a digital product in Saudi Arabia

Start by classifying what you are actually building

Before any conversation about technology or budget, settle one question: is this an external product, an internal tool, or a feature of something you already run? The answer determines the team, the success criteria and how the money should be spent.

These get conflated constantly. An internal tool serves your own staff and is judged on operational time saved. A feature extends an existing product and is judged on its effect on how that product is used. A standalone digital product has an external user, a distribution channel and a revenue model. Treating one as another is the most common reason a well-funded build ends up abandoned.

The practical difference is blunt. An internal tool succeeds when the team uses it because management said so. An external product has no such support: the user has to choose it, come back, and usually pay. Its budget is therefore never just development — it is development plus acquisition plus support plus continuous improvement for months after launch. If those last three lines are missing from your plan, you are building an internal tool and calling it a product.

A quick test: if you stopped all marketing spend tomorrow, would anyone still use this? If yes because employees have no alternative, it is a tool. If yes because someone outside the company finds it worth the effort, it is a product. Write the classification on page one of the scope document and hold every later decision against it.

Four questions to answer before the first line of code

These are not strategy exercises. Each one changes the technical scope directly, and answering any of them late means rework.

Who has this problem today, and how do they solve it without you? The answer there is no current solution is almost always wrong. In this market the incumbent is frequently a spreadsheet, a WhatsApp group, a staff member making phone calls, or a paper ledger. That workaround is free and familiar, and it is the benchmark your product will be judged against.

Who pays and who uses? In business-to-business products these are usually different people with conflicting criteria. The manager wants oversight and reporting. The person doing the job wants to finish a task in as few steps as possible. Serve only one and you get a product that is bought but not used, or used but not renewed.

How does the first user arrive? If the answer is not concrete — an existing customer list, a distribution partner, a content channel with an audience, a sales team — then you are building and hoping. Decide the channel first, because it imposes real requirements: self-serve signup demands a tight onboarding experience, while field sales demands an admin console and support tooling far more than a pricing page.

What would make you stop? Write the kill criterion down before you start, in plain language and with a date attached. The difference between a disciplined project and one that quietly bleeds is whether that sentence existed before stopping became personally awkward.

Scoping version one: the one-complete-journey rule

The expensive mistake in a first release is rarely the technology choice. It is covering several user journeys at half quality instead of one properly.

The rule we work to: pick a single journey and build it end to end, including the ugly parts. End to end means signup, the empty state a new user sees first, the happy path, the error cases, the notification, the invoice if there is one, and the screen shown when something fails halfway through. A product that does one thing without gaps beats one that does five and breaks the moment a user leaves the ideal script.

To choose that journey, rank the feature list on two axes: how often a user needs it in a normal week, and how much it hurts when it is missing. Build what scores high on both. Everything else goes onto a separate list titled after our first ten real users, and is not discussed before then.

What can usually be cut from version one without real loss: multi-level permission systems, a native mobile app alongside the web build, an analytics dashboard for the end user, integrations nobody explicitly asked for, and a second language if your first audience is entirely local. Each looks small on a slide and consumes weeks in build, test and maintenance.

Put all of this in a two-page scope document with an explicit section headed out of scope. That second section will save you more argument than the first one.

Local constraints that belong in scope on day one

These are not finishing touches. Each changes the structure of the product, and handling any of them late means rebuilding something.

Arabic and right-to-left. Treat Arabic as a primary language in design and data model, not a translation layer applied afterwards. Direction affects layout, icons, charts and button order. Numerals and dates need a written decision: which calendar is displayed, which numeral forms, and how Arabic names sort. Defer these and you get an interface that reads as machine-translated even when the words are correct.

Mobile first. Assume the first session happens on a phone, often on an unreliable connection: one-thumb layouts, disciplined asset sizes, sensible behaviour when the network drops mid-action.

Authentication. Mobile number plus a one-time code is the familiar path for most users here. It carries a per-message operational cost and needs abuse protection designed in. If your product requires verification against official identity, that is a separate workstream with its own integration and legal review, and should be estimated as its own line item rather than buried inside a signup screen.

Payments and invoicing. If money changes hands, supporting the locally common payment methods is part of the product, along with refunds, partial failures and reconciliation. If your product issues tax invoices, e-invoicing requirements from the Zakat, Tax and Customs Authority belong in the technical scope and should be confirmed with a qualified adviser. If it provides financial services or moves funds on behalf of others, the Saudi Central Bank is the relevant authority and this is subject to legal review before you build, not after.

Personal data. Processing user data in the Kingdom falls under the Personal Data Protection Law overseen by the competent authority. In practice that turns into design decisions: what you actually collect, where it is stored, how long you keep it, and how it is deleted. Make those part of the architecture review and have a qualified adviser look at them before launch.

Team, stack and cadence: decisions you make once

The smallest team that can ship a serious first release covers four roles, and one person can hold two early on: a product owner who controls scope and replies within a working day, a designer who maps the journeys and writes interface copy, one or two developers covering front and back end, and quality assurance even part-time. The role most often dropped is the product owner; the consequence is that every small decision escalates to a weekly meeting and the timeline doubles.

On the stack, choose what your team is genuinely good at and what you can hire for locally. Early-stage products almost never fail because of the framework. They fail regularly because nobody could maintain the code after the first developer left. Hosting region is worth deciding early, particularly if you have views on where data should physically sit.

What we do not compromise on, even in version one: a single repository with a readable history, automated deployment to a staging environment, backups that have actually been restored at least once, and error monitoring that reaches a named person. None of this is luxury; its absence turns a minor fault into a full day of downtime.

On cadence, work in short cycles that each end with something usable, and keep a staging link open to decision-makers throughout. Projects where the result is revealed once at the end are the ones that finish with an unpleasant surprise for both sides.

What to measure in the first ninety days

Launch starts the phase that most first-time builders neglect: turning usage into decisions.

Two weeks before launch, write down the events you will track and give them clear names — signup completed, empty state reached, first successful action, that action repeated within seven days, and the drop-off points along the main journey. Events added after launch cost you the first weeks of data, the most informative you will ever have.

The number we ask clients to watch in month one is not signups. It is the share of users who reach first real value. Signups are cheap, easy and misleading. The moment a user thinks this is useful to me is what predicts whether they come back. Watch where exactly people stop, not merely how many.

Quantitative data tells you where the problem is and never why. Book time every week for short conversations with real users; ten calls in the first month typically reveal more than a full analytics dashboard, and reveal it sooner.

Finally, decide in advance what you will do with the answer. If the main journey breaks at a particular step, will you fix that step or revisit a deeper assumption? Deciding ahead of time stops a team polishing surfaces while the flaw sits in the premise.

Recurring failure patterns and a pre-launch checklist

The failure patterns in first products are monotonously similar. A version-one scope that is really a two-year plan. An Arabic or English version produced by literal translation, quietly costing the product its credibility. Payments and authentication deferred until after design, forcing screens to be rebuilt. No single decision owner, so every review costs a week. Launching without measurement, then arguing about impressions instead of evidence. And treating launch as the end of the project rather than the start.

The pre-launch checklist we actually use:

Can someone who has never seen the product complete the main journey unaided? Has every screen been tested on a real phone, in Arabic, in the correct direction? Does every screen that can start with no data have a written empty state? Do error messages tell the user what to do rather than what went wrong on the server? Has a restore from backup been performed at least once for real? Does a production error reach a specific named person? Is event tracking live and verified in production, not only in staging? Is there a published support channel with someone accountable for replying? Have the privacy policy and terms been reviewed by a qualified adviser? Are all accounts, domains, repositories and service keys in your company name rather than an individual or a vendor?

A no is not automatically a reason to delay launch. But it should be a conscious, written decision, not something you discover after the first customer does.

Key takeaways

  • Write down whether this is an external product, an internal tool or a feature — on page one of the scope document — and hold every later decision against it.
  • Cut version one to a single journey built end to end, error states included, and park everything else on a list you do not open until you have ten real users.
  • Put language and direction, authentication, payments, invoicing and personal-data handling in scope on day one rather than after design.
  • Define and approve your tracking events two weeks before launch, and watch the share of users reaching first real value rather than signup counts.
  • Agree a written kill criterion with a date before you start building.

Frequently asked questions

How long does a first version take to build?

It depends on how many journeys are in scope and how much integration is involved. A single complete journey with mobile-number authentication and no complex integrations typically lands in a range of several months from discovery to launch. Adding payments, official identity verification or integration with an existing system extends that materially. The reliable estimate comes after a discovery session where the journeys are actually defined.

Should we start with a mobile app or a web product?

Start with responsive web in most cases: distribution is immediate, the update cycle is faster, and experiments cost less. A native app becomes justified when push notifications are core to the value, when offline use matters, when you need device capabilities, or when usage is genuinely daily and habitual. Decide from expected usage behaviour rather than general preference.

Do we need registrations or licences before launching?

It depends on the activity and the sector, particularly where payments, financial services, health, education or sensitive data are involved. This sits outside technical advice and is subject to review by a qualified legal adviser before launch. We recommend doing that review before the build rather than after, because the outcome can change the scope.

What if we have no in-house technical team?

A first version can be delivered entirely with an external team, but one role has to stay internal: a product owner who controls scope and responds within a working day. Without it every review becomes a wait. We also recommend that accounts, domains, the code repository and service keys are in your company name from day one, whoever does the work.

Sources

Have an idea, or a system that needs work?

Start with a short session to understand where you stand and what the next step should be. If the scope is clear, a written proposal follows.