
Scope the first version of your product around one job it does for one specific customer, from start to finish. Then put every proposed feature in one of three buckets: needed for the first paying customer, doable by hand behind the scenes, or later. You build the first bucket now. Your team covers the second with spreadsheets and existing tools. The third goes on a written later list that nobody reopens until paying customers ask for it.
A few things sit below the buckets and never get cut: keeping each customer's data away from the others, backups you have actually restored, a way for customers to take their data, the basics of billing, and Arabic support if your market writes in it. Below you'll find the method applied to an example, plus a one-page scope template to write before you ask any development team for a quote.
What the first version of a product has to prove
The first version proves that a specific customer will pay to get one job done your way. Eric Ries defined the minimum viable product (MVP) in a 2009 post as the version that lets a team collect the most validated learning about customers with the least effort. The word that matters in that definition is learning. The feature count follows from it.
This article assumes you've already tested the idea: you've talked to potential customers, shown them the promise and the price, and maybe delivered the service by hand to a few. If you haven't, start with how to build a SaaS product from idea to first paying customer, and come back when you reach the question of what to build first.
The trouble at this stage is that the feature list grows with every meeting. Each prospect asks for something, each competitor shows something, and each feature looks small on its own. The method below gives you a written reason to say "later".
Write down the one job customers pay for
The one job is the result customers pay for, written in a sentence someone outside your field can follow. Use this template:
[Type of customer] uses the product to [result], in place of [what they do today].
Here's a hypothetical example we'll use for the rest of the article: "A residential compound manager uses the product to close every maintenance request residents raise, and to know who closed it and when, in place of WhatsApp groups and a paper notebook." The sentence leaves out reports, a mobile app and fee collection. The product may need them one day. They aren't the job today.
If you need an "and" to join two jobs in that sentence, you have two products. Pick the one you heard about most in customer conversations, or the one people already paid for, and park the other.
Map the shortest workflow that does the whole job
The workflow is the set of steps a user goes through from logging in to getting the result, and the first version covers all of it, even if roughly. A plain workflow that runs end to end beats half a polished one, because nobody pays for half a result.
Write the steps in order, each starting with a verb. In the hypothetical example:
- The manager signs in and adds the compound, the units and the technicians.
- A resident submits a request from a link, with a description and a photo.
- The manager assigns it to a technician.
- The technician marks it done.
- The resident gets a notice that the request is closed.
- The manager sees open requests and how old each one is.
Ask of each step whether the workflow still completes without it. If it does, the step is outside the workflow and gets sorted with the other features. Here the workflow technically completes without step six, but managers buy the product to know what's still open, so that step is part of the job and stays.
Sort every feature into one of three buckets
Put each proposed feature in a single bucket and write down why it's there. The written reason is what protects you when the same argument comes back a month later.
| Bucket | The question that decides it | What you do with it |
|---|---|---|
| Needed for the first paying customer | Does the workflow break without it, or will the first customer refuse to pay because it's missing? | Build it now, in the simplest form that works |
| Manual behind the scenes | Can someone on your team do it for a handful of customers without the customer waiting? | Your team does it with a spreadsheet or email and logs the time it takes |
| Later | Did a paying customer ask for it, or did it come from the team or a competitor's feature page? | Add it to the later list with the name of whoever asked |
Applied to the hypothetical example:
| Feature | Bucket | Reason |
|---|---|---|
| Submitting a request from a link, no app install | Needed | Start of the workflow |
| Assigning a request and changing its status | Needed | The core of the job |
| Telling the resident the request is closed | Needed | End of the workflow |
| Importing units and residents from a file | Manual | Your team enters them for early customers |
| Monthly report for the board | Manual | Pull it from the database and email it |
| Mobile app for technicians | Later | A mobile-friendly web page is enough to start |
| Collecting maintenance fees from residents | Later | A second job, maybe a second product |
| Accounting software integration | Later | No paying customer has asked yet |
| Dashboard with charts | Later | The open requests list answers the question for now |
The manual bucket is the one founders overlook, and it saves the most. Anything a person can do for a small number of customers can wait for code, as long as the customer doesn't feel a delay. Log the weekly time each manual task takes. That log tells you later what deserves code first.
Be wary of features that look essential because every competitor has them. A competitor with years in the market built those features over those years. Ask your first customers what stops them from paying, and for now set aside what they like about other products.
What never gets cut from the first version of a product
Some items skip the sorting altogether, because leaving them out costs you the customer, their data or their trust, and adding them after launch is harder than building them in. Treat them as a fixed floor:
| Item | Minimum in the first version |
|---|---|
| Permissions and data separation | Each user sees only their company's data, each role sees what belongs to it, and there's a written test for it |
| Backups | An automatic daily copy stored off the main server, and at least one test restore before launch |
| Data export | A way for customers to get their data in a file they can open in a spreadsheet |
| Billing basics | A record of what each customer paid, a correct invoice, and a way to pause an unpaid account |
| Arabic, right to left (RTL) | Every screen works in Arabic from day one if your customers write in it |
| Personal data | You know what you store about people, why, and who can reach it |
Permissions come first. Broken access control holds the top spot in the OWASP Top 10 for 2025, and one of its examples is a user changing a number in a page's address and seeing someone else's account. Ask your developer to test exactly that case before the first customer signs in.
A backup you've never restored is a backup you can't count on. Export reassures customers who worry about their data being locked in, and company procurement teams may ask about it before signing. Invoicing rules differ between the two countries, and we cover them in what e-invoicing requires of your company in Saudi Arabia and Egypt.
Adding Arabic after launch means going back through every screen. The W3C recommends setting page direction in the HTML itself with the dir attribute rather than in stylesheets alone, and your developer also needs to test numbers, dates and text that mixes Arabic with English.
Your product will store names and phone numbers at the very least. Egypt has Law No. 151 of 2020 on personal data protection, and Saudi Arabia has the Personal Data Protection Law published by SDAIA. This paragraph is a pointer and not legal advice, so check what applies to your product with a specialist before launch.
The floor adds time to the first version, on purpose. Cut features before you cut the floor.
Write a scope page before you ask for a quote
A scope page is a single page that pulls all of this together, and you hand it to the development team before any quote. Everyone compares against the same document, and any later addition shows up as a change with its own time and cost. Additions that slip in one by one without a decision are what developers call scope creep.
Copy this template and fill it in:
| Item | What to write |
|---|---|
| The one job | Your sentence from the template |
| First customer | Who they are, which country they work in, and in what language |
| Workflow | The steps in order, from sign in to result |
| Built now | The first bucket, with a reason for each feature |
| Done by hand | The second bucket, who does it, and for how many customers your team can keep it up |
| Out of scope | The whole later list, written out |
| The floor | Permissions, backups, export, billing, Arabic and personal data |
| Success measure | What has to happen after launch for the version to count as a success, such as paying customers using it without reminders |
The most important line on the page is "out of scope". A list of what you won't build prevents more misunderstanding than a list of what you will, because each side fills gaps with its own expectations. If one page can't describe the workflow, the scope is probably bigger than a first version.
Signs the scope is still too big
- The job sentence only works by joining two jobs.
- The first bucket holds features no customer you spoke with asked for.
- The manual bucket is empty, which usually means nobody asked what could be done by hand.
- More than one type of user needs their own dashboard on day one.
- The team talks about a "platform" before anyone has paid.
- The estimated build time is longer than you can fund the project with no revenue.
If two or more of these show up, go back to the job sentence. That's where the problem usually starts.
How to decide what goes in after launch
A feature moves from the later list to the build list when paying customers give you evidence for it, rather than when the team runs out of other work. Set your rule before launch. For example, a feature moves up when one of these holds:
- More than one paying customer asked for it, each without hearing it from the other.
- The manual work behind it takes enough team time to stop you serving new customers.
- A prospect declined to subscribe because of it, and said so.
- Usage data shows customers dropping off at a step this feature would fix.
Review the later list every month. Some of what felt essential before launch will turn out to be something nobody asked for, and finding that out is one of the main things a first version teaches you. Which features go in higher plans and which stay in the basic one depends on your pricing model, a separate decision from scope.
Your next step
Open a new file today and write your job sentence with the template. Then list every feature on your mind, even if there are thirty, and put each one in a bucket with its reason. Show the result to two potential customers and ask which missing feature would stop them paying. If the system is only for your own company and you won't sell it, the math is different, and you'll find it in when your company needs custom software.
When your scope page is done and you need a team to estimate and build it, you can go through it with PlanKit's SaaS product development team.