If you're commissioning custom software and all you send a few vendors is a two-line message, the quotes you get back won't be comparable. One comes in low and another at several times that, because each vendor has guessed at your needs differently. The fix is to put the problem, users, must-have features, sample data, integrations, budget and deadline on a single page before you contact anyone. The checklist below builds that page, and later it helps you weigh the proposals fairly.
What information should you prepare before commissioning custom software?
You need eight things. The first four describe the work itself: the business problem, how the work gets done today, the users and their access levels, and the must-have features for version one. The next four frame the project: anonymized sample data, the integrations you need, a budget range and a target date. Add three more alongside them: who makes the final call, the acceptance criteria for the output, and what's out of scope. With all of that in hand, a vendor can write you a much clearer proposal.
My suggestion is to gather everything on a one-page form, with each item's status and the person following it up written next to it. Something like this:
Item | Key question | Status | Owner |
|---|---|---|---|
Business problem | What exactly isn't working right now? | Ready / Unknown | Name and role |
Current process | What tools do you use for this today? | Ready / Unknown | Name and role |
Users and access | Who does the work, and what is each person allowed to do? | Ready / Unknown | Name and role |
Version-one features | Which feature can't you start without? | Ready / Unknown | Name and role |
Sample data | Do you have an anonymized or dummy file? | Ready / Unknown | Name and role |
Integrations | Which systems should the new software exchange data with? | Ready / Unknown | Name and role |
Budget range | What range can you genuinely allocate? | Ready / Unknown | Name and role |
Deadline | Is the date preferred or fixed? | Ready / Unknown | Name and role |
Decision-maker | Who gives final sign-off on scope and cost? | Ready / Unknown | Name and role |
Acceptance criteria | How will we know the output is acceptable? | Ready / Unknown | Name and role |
Out of scope | What is deliberately left out of version one? | Ready / Unknown | Name and role |
This form isn't a detailed requirements document. You usually write that after discovery, meaning the sessions where you and the vendor work through the problem together. So wherever you don't know the answer, mark it “Unknown” and move on. A guess that stands in for a fact today will cause trouble halfway through the estimate tomorrow.
What decisions need to be made before you commission?
Make four decisions before you start: who owns the problem, who makes the final call, why the current way of working has to change, and what success looks like. Leave any one of them blank and even the best vendor is building on shaky ground. Every time they reach a fork in the road, nobody is there to give a definite answer.
Problem owner: the person who deals with this problem every day and knows the details. That's why the vendor will send most of their questions to them.
Final decision-maker: the person who approves scope and cost. If two managers disagree, settle it before you commission, not mid-project.
Reason for change: what has happened that means the current approach no longer works? Growing volume, a recurring error, a new requirement?
Sign of success: a few months after launch, how will you know the project was worth it?
Before you commission any build, check whether the problem really lies with the tool or with a process nobody owns. If it's unclear who approves a purchase request, for example, software won't make it clear. It will just move the same confusion onto a screen and hide an internal disagreement behind a tidy interface.
Write your success criterion as a sentence you can test. “Things get better” isn't a criterion. “Every purchase request must have an owner and a clear status” is, because you can check it on delivery day. The first question I usually ask a client is exactly this: what do we need to see on delivery day to say the work is right?
Maybe you're still not sure a custom build is the best route. If so, read What is custom software, and when does it make sense? before commissioning anything. This checklist is for when you've already decided to build.
How do you write a short, clear problem statement?
One four-part sentence is enough: who does what, how they do it, and where exactly it goes wrong. When commissioning custom software, these few lines affect the accuracy of the estimate more than anything else, because this is where the vendor first sizes up the work. Copy this template:
“Right now, [user group] handles [process] using [current method]; the problem is [specific thing that happens], and the desired outcome is [testable result].”
Take a hypothetical purchasing team. Its problem statement might read: “Right now, purchasing staff receive requests through messaging apps and phone calls; requests go missing and nobody knows their approval status.” The desired outcome is just as clear: version one should bring request logging and tracking into one place. Those two sentences tell the vendor who they're dealing with and what hurts.
Now add three more items to round out the request. Don't underestimate the exception. The surprises during testing usually come from cases nobody wrote down.
Normal scenario: a warehouse employee submits a request, the purchasing manager approves it, and a purchasing officer places the order.
Exception: the purchasing manager rejects the request. What happens next, and how does the requester find out?
Required output: a status report on all open requests, broken down by owner.
Be careful, though, not to let the problem statement turn into a prescription. “We want a professional dashboard” tells the vendor nothing. Instead, write down what decision the purchasing manager has to make each morning, such as which requests have been stuck for more than three days. Get clear on the decision yourself and leave how it's displayed to the design team.
What sample data and documents should you prepare?
The documents you need fall into three groups: your current forms and reports, dummy or anonymized sample data, and documentation for your existing systems. You don't need all of it to be complete. Whatever you have is enough, as long as it comes with an explanation.
Group | Example | What it tells the vendor |
|---|---|---|
Current forms and reports | Paper request form, tracking spreadsheet, monthly report | What data you capture and what output you need |
Dummy or anonymized sample data | A few dozen rows with the real structure and made-up values | The shape of the data, its columns and its unusual cases |
Existing system documentation | Docs for your accounting or inventory software | Whether integration is possible and how hard it will be |
Next to each file, note three things: who owns it, where it's used and which requirement it relates to. A folder of dozens of unexplained files makes the vendor's job harder, not easier, because they have to guess which file matters and which was just left behind. A pile of files is no substitute for one clear explanation.
A clean sample on its own doesn't show the state of your real data, either. Say your sample file has fifty tidy rows, but the real data is several years of history full of duplicate names and empty columns. So note separately the approximate number of rows, the quality of the data and whether old records need migrating. Data migration can be a small project in its own right, and if it's discovered late, it pushes back the whole schedule.
Be strict about privacy. Strip names, phone numbers, national ID numbers, account numbers and any real financial information from your samples. Don't include passwords or integration keys in your initial request either. Hand those over only after you've reached an agreement, and through a secure channel.
For integrations, one term is worth knowing: the application programming interface, or API. It's the door through which two pieces of software exchange data. Ask the provider of your current system two things. Is the API documentation available? And is there a test environment, meaning a separate copy where testing doesn't touch real data? The answers to these two questions directly affect the estimate for your custom software.
How do you define users, integrations and the scope of version one?
Pin down three things: users, with their roles and permissions; integrations, with their direction and owner; and scope, split into three groups of features. Together these account for most of the workload, so any ambiguity here flows straight into the estimate. For users, tick off the following:
Roles: requester, approver, purchasing officer, manager.
View and edit permissions: who can only view, and who can edit or delete?
Concurrent users: this number matters, because ten people working at once need a different architecture, meaning the technical structure behind the software, than several hundred.
Devices: office computers, mobile phones, or both?
Scope is the set of work covered by the agreement, and nothing more. When commissioning custom software, split features into three groups:
Group | Meaning | Example for the hypothetical purchasing team |
|---|---|---|
Essential to start | Without it, the software is no use | Request logging, approval, status report |
Can wait | Useful, but doesn't block launch | SMS notifications, advanced archiving |
Out of version one | Deliberately excluded from this agreement | Accounting integration, pending a technical review |
The accounting integration is left out on purpose in this example. Until someone has reviewed that software's API, committing to it means making a promise based on a guess. For each integration, record five things: the source system, the destination, the direction of exchange, who owns access, and what happens when the connection drops. That last one is usually forgotten. If the destination system is down for a few hours, where does the data wait? If one of your integrations is with a customer relationship management (CRM) system, the guide Defining requirements for a CRM integration goes into more detail.
Also write at least one observable test for every essential feature, for example: “A rejected request can't be closed without a reason being recorded.” The QA team can turn that sentence straight into a test, and you can try it yourself on delivery day.
A feature you can't test on delivery day isn't a requirement yet. It's a wish.
How should you state budget and target date along with your constraints?
Instead of a single figure, give a budget range, state the deadline along with the reason for it, and spell out any constraints tied to either. With a realistic range, the vendor can shape the scope to fit. With your silence, all they can do is guess. Fill in this checklist:
Available range: the minimum and maximum you actually have to spend.
Costs beyond the build: hosting (the server the software runs on), third-party services, training and maintenance.
How extra costs are approved: who signs off on changes, and up to what limit?
Scope flexibility: if the budget falls short, which feature moves to the next version? SMS notifications or advanced archiving, for example.
Separate a preferred deadline from a hard one. “Ideally by the end of the quarter” is very different from “the contract for our current tool ends at the end of the month.” So write down why a hard deadline is hard, so the vendor knows where there's no room to give.
Remember that the timeline for custom software isn't just programming time. Preparing data, getting access from another provider and your own approvals all take time too. In my experience, these dependencies move the schedule more than the coding itself. So put them in the request from the start, for example the fact that approving each stage in your organization usually goes through several people.
If the budget isn't approved yet, say so and ask for an initial estimate along with its assumptions. Don't invent a figure just to get a proposal; a proposal built on a made-up number is no use to you. When commissioning custom software, being honest about budget saves both sides time.
Shrinking version one is not the same as cutting testing and security, though. Here's the difference:
Sensible trimming | Risky savings |
|---|---|
Postponing rarely used reports | Dropping acceptance testing |
Postponing the accounting integration | Simplifying access controls |
Entering a few dozen old records by hand | Removing automatic backups |
Simpler page design | Ignoring basic security requirements |
On security minimums, ask the vendor which parts of the Application Security Verification Standard they cover in their testing. A clear answer is a good sign of a mature team. A vague line like “we take security seriously” shows nothing.
What should a discovery session produce?
The output of this session should be in writing: a document recording the initial scope, the assumptions and the open questions. Discovery means clarifying the problem, the ambiguities and the constraints before anyone commits to delivery. A meeting spent on introductions isn't discovery. After the session, you should have these six things in hand:
Meeting notes: what we discussed and what we agreed.
Initial scope: an updated version of the three feature groups.
Estimate assumptions: for example, “old records will not be migrated.”
Open questions: things nobody knows the answer to yet.
Who answers: a name and a date next to every question, because a question without an owner usually stays open until estimate day.
Next step: who sends what to whom.
The usual path for commissioning custom software, from sending a request to receiving a proposal, looks roughly like this. It's only a suggested pattern, not a timing commitment from Niasa; how long each stage takes depends on the project.
Send the one-page request
Review the ambiguities and send questions
Discovery session
You approve the initial scope
Receive the technical and financial proposal
Sometimes the uncertainty around integrations or data migration is so large that no estimate can be relied on. In that case it makes more sense to commission a limited technical review before any delivery proposal. Ask separately what it costs and what it produces, for example a feasibility report on the accounting integration.
Meanwhile, everyone in these meetings has new ideas. In the middle of a discussion about request approval, someone says, “It'd be great to have SMS notifications too.” My habit is to write every new feature on a separate list, not into the scope. None of them should make it into version one without your explicit approval.
What checklist should you use to review technical and financial proposals?
Don't settle for the bottom-line number. Assess proposals against a fixed checklist that puts scope, assumptions and cost structure side by side. The first condition is simple: in your request for proposals, ask every vendor to respond to the same version of the brief. If you give each vendor a different story, the comparison is broken from the start, because each one has answered a different question.
Deliverables: exactly what will you receive? Installed software, source code, documentation?
Out-of-scope items: a proposal without this section leaves a lot open to interpretation.
Assumptions: what has the vendor counted on? For example, that old records won't be migrated.
Dependencies: which tasks hinge on you or on another provider?
Delivery stages: how many stages, and in what order?
Acceptance criteria per stage: how will you know each stage is finished?
Then separate the build cost from everything else. In other words, check whether each item is included in the price or charged separately. Here's a comparison of two hypothetical proposals:
Cost item | Proposal A | Proposal B |
|---|---|---|
Software build | Included | Included |
Hosting | Separate | Separate |
Third-party services such as SMS | Separate | Unspecified |
Legacy data migration | Included | Not mentioned |
User training | Included | Separate |
Post-delivery maintenance | Separate contract | Separate contract |
Suppose Proposal B's bottom line is lower. But it doesn't mention data migration, and the SMS cost is unclear. So rather than comparing totals, first mark the differences in scope, then put the prices side by side.
A lower number sometimes just means less of the work has been priced.
Send one question, word for word, to every vendor: “Which assumption, if it changes, would change the price or timeline in your proposal?” Then look at how each vendor announces changes and who approves them. From a project management point of view, the way changes are handled says more about the future of the working relationship than the initial figure does. If the scope isn't final yet, also ask how firm the estimate is and how long it remains valid. An initial estimate is a useful guide, but don't mistake it for a fixed contract price.
What needs to be settled before you sign?
Before you sign a contract for custom software, get ownership, maintenance, payment and backups down on paper. These seem unimportant while the project is going well, but on the day of a dispute they're everything. Here's the checklist to go through before you agree:
Ownership of code and data: once you've paid in full, who owns the code and the data?
Code repository handover: the repository is where the code and its change history are kept. Ask for full access to it as part of delivery.
Infrastructure access: whose name are the server account and the domain registered under?
Third-party licenses: sometimes the software depends on a paid service or library, meaning a ready-made package of code you have to buy a license for. In that case, who pays for the license and who owns it?
Bug or new feature: separate the definition of a bug from a request for a new feature. Write down the bug-fix period, the maintenance terms and how requests are submitted. Without that line, every request turns into an argument over whether it's a bug or new work.
Staged payments: tie each payment to an acceptable deliverable, not to the passage of time.
Full handover: training, documentation and a way to export your data should all be part of delivery.
Backups and sensitive access: name who is responsible for backups, restore testing and looking after passwords.
Having a backup file proves nothing on its own. From a QA standpoint, a backup you've never tried restoring is just a hope. So put a trial restore in the delivery plan and record the result in the handover report.
This list isn't a substitute for a proper contract, though. If commissioning your custom software raises any legal ambiguity or sensitive ownership questions, go over them with a legal adviser before you sign.
نمونهکارهای ما در همین زمینه
How should a sample request be prepared for Niasa to review?
Prepare your request using the same one-page form, and use the example below as a model. It's hypothetical and the data is made up; it simply shows what a request looks like in practice. With this structure, any vendor will understand your project faster and more accurately, without needing several calls just to grasp the basics.
Section | Hypothetical example with made-up data |
|---|---|
Problem | Right now, 12 purchasing users receive requests through messaging apps; requests go missing and nobody knows their approval status. |
Version one | Request logging, purchasing manager approval, status report on open requests |
Out of version one | Integration with the accounting software, pending a technical review |
Attachments | One file with thirty dummy requests, plus the current paper form |
Budget | Not approved yet; a staged estimate is needed. |
Target date | Before the next purchasing cycle; exact date to be agreed |
Acceptance criteria | A request can't reach final status without the purchasing manager's approval. |
Open question | Whether the accounting integration is really needed is still unclear. |
Point of contact | [Name, role and contact details] |
Before you send it, do one last pass to make sure nothing is missing:
A one-page brief, with “Unknown” items flagged
Anonymized attachments with no real personal or financial information
The name of the person who will answer questions
A list of open questions
No sensitive internal documents attached, such as current contracts or financial statements
If you'd like our team to look at whether your project is feasible, send your request through the contact options on the Niasa custom programming and software page. That request is where our review of your custom software starts. We usually follow the path above: going through the ambiguities, a discovery session, and then a proposal. But response time, pricing and whether we take on the project can only be confirmed once we've reviewed the request itself.
So your next step is simple:
This week, fill in the one-page form and mark anything you don't know as “Unknown.”
Assign every unknown item to an owner with a clear date.
Send the same version of your request to every vendor you're considering.
Assess the proposals with the checklist from the technical and financial proposal section, not by the bottom-line number.
شرح یکصفحهای و پرسشهای باز را برای نیاسا بفرستید تا گفتوگو درباره امکان اجرا از نیاز واقعی شما شروع شود.
Frequently asked
4Do we need programming knowledge to commission software?
No. You need to be able to explain your day-to-day work, the problem and the outcome you expect. Leave the technology choice to the technical team, but ask why they chose it and what its limitations are.
Can we send an initial request without a complete requirements document?
Yes. A short description with a real scenario from your work is a good way to start the conversation. Flag the unclear parts so they get reviewed before anyone commits to a price or timeline.
Do we have to send real customer data to get a proposal?
Usually not. Dummy data with the same structure is enough for an initial review. If a later review does need sensitive data, settle how access will work and the confidentiality commitment in advance.
Why do quotes for building software vary so much?
Vendors may be making different assumptions about features, delivery quality or responsibility for data migration. First align what's in and out of each proposal, then compare the price and payment terms.






