How we estimate a project: scope, cost, timeline — and why there are no surprises
What happens before development starts, what drives cost and timeline, how we lock scope and price, and why the client hears about changes in advance rather than after the fact.
We estimate a project in three steps: first we understand the task (discovery), then we sketch the structure of the solution, and only after that do we fix scope, cost and timeline in writing — before the first line of code. If something later affects the budget or the dates, we raise it and agree on new terms first, and then continue.
One of the most common sources of frustration in IT projects is when the final cost and timeline don't match what was discussed at the start. We've built our process to prevent exactly that. Here's how it works.
What happens before a price is named?
Every project starts with a deep dive. We ask questions: what problem needs solving, who will use the system, which processes it will affect, what is already in place. This isn't a formality — without a clear understanding of the task, any estimate is essentially a guess and will almost certainly be inaccurate.
The output of discovery is a document describing the task, constraints, and the criteria for a finished result. That document becomes the foundation for the estimate.
The criteria for a finished result are the most underrated part of that document. "Build a convenient customer account" cannot be verified. "The customer sees their orders, downloads an invoice and changes the delivery address" can, and with a list like that both sides understand in the same way when the work is done.
Why sketch the solution before estimating?
Before we put numbers on the table, we sketch the architecture: which modules are needed, how they interact, which integrations will be required. For products with a user interface we draw a screen flow or a simplified prototype — so both sides have a shared picture of exactly what will be built.
This step eliminates most misunderstandings before work begins. The same word — "catalogue", "customer account", "CRM integration" — means different things to different people, and the gap between those pictures can amount to weeks of work. On a diagram it shows up immediately.
What exactly is fixed before development starts?
Before development starts, we fix three things:
- What is in scope — a concrete list of features and screens, no vague language
- What it costs — broken down by module or phase
- When it will be ready — realistic dates that account for our current workload
The client signs off on this before the first line of code is written. No verbal agreements.
The breakdown by module is useful for more than control. It shows what each part costs, so if the total is above expectations you can deliberately remove something or move it to a later phase, instead of asking to make everything "cheaper" at once.
What drives the cost of a software project?
The price comes not from the number of pages but from the amount of work behind them. The main factors:
- Scenarios and roles. How many types of users there are and what each of them does in the system
- Integrations. Payments, CRM, accounting systems, external services — each depends on documentation and access on someone else's side
- Design. A solution built on ready-made components, or a fully custom interface
- Languages and content. Every language version means copy, layout and checking
- Data. Whether it has to be migrated from an old system, and what state it is in
- The admin panel. What you want to change yourself, without a developer
- Load and security requirements.
For how this plays out on a website, see our articles on the stages of a turnkey website and on website costs in Yerevan.
What drives the timeline?
A timeline is more than development hours. It is shaped by things that sit outside the code:
- Feedback speed. How long it takes to look at a result and respond
- Content. Copy, photos, price lists — and when they will be ready
- Access. Accounts, keys for external services, reviews on third-party platforms
- The number of approvers. The more people sign off on a result, the longer every cycle
That is why it helps to agree before the start who makes decisions on your side and how quickly they respond.
How does the work go once the estimate is signed?
We work in one-to-two-week iterations. At the end of each iteration we show a working result — not slides, but a real product in a browser or on a device. The client sees progress and can adjust priorities while changes are still inexpensive.
This matters for the estimate for a simple reason: a gap between expectation and result is found within a week or two, not at the end of the project, when fixing it touches parts that are already finished.
When does the estimate change — and how do we communicate it?
An estimate may change if:
- New requirements emerge during the work that weren't in the brief
- An integration with an external system turns out to be more complex than expected
- The client wants to add or change functionality
In such cases we first communicate the scope change, agree on a new price and timeline — and only then continue. The client never discovers an overrun after the fact.
A change in itself is not a problem: good ideas almost always appear along the way. The problem is a change that nobody priced.
What should you prepare to get an accurate estimate?
- The goal in one or two sentences. What should change in the business after launch.
- Who the users are and what they need to be able to do in the system.
- Examples. Websites or services you like and dislike, and what exactly about them.
- Existing systems. What the new solution has to connect to: CRM, accounting, payments.
- Constraints. A hard date, a budget range, legal requirements.
- Who makes decisions on your side.
It is worth naming the budget range up front. That lets us propose a scope that fits it, rather than an estimate that will have to be cut down later.
What mistakes do people make when comparing estimates?
- Comparing totals instead of scope. Two estimates with different prices almost always describe different sets of work
- Accepting a one-line estimate. Without a breakdown you cannot tell what is included
- Reading a "from" price as the final one
- Not asking what happens when something changes. If the procedure is not written down, it will surface at the least convenient moment
- Forgetting the costs after launch. Hosting, the domain, paid external services, support
When is a fixed estimate the wrong tool?
Scope, price and timeline can be fixed when the task is understood. If a substantial part of it is research, it is more honest to estimate only the first stage: discovery, a prototype or a pilot. This is the case when the idea has not yet turned into requirements, when an integration with an undocumented system is needed, or when the quality of the result can only be checked on real data — as in AI projects, which we wrote about in our article on integrating AI into a business. After the first stage, the rest is estimated on facts.
Transparency instead of surprises
Our principle is simple: anything that affects the budget or timeline must be discussed before it becomes a reality. This demands discipline on both sides, but it's the only way to build a long-term working relationship.
If you have an idea or a task — tell us. The first conversation is free, and by the end of it you'll know exactly what needs to be done and what it costs. Examples of finished projects are in our case studies.
FAQ
Is the first conversation about a project paid?
No, the first conversation is free. By the end of it you will know what needs to be done and what it costs.
Can you give a price without a brief?
Without understanding the task, any number is a guess and will almost certainly be inaccurate. That is why we start with questions about the task, the users and the systems already in place.
What happens if I want to add a feature in the middle of the project?
We tell you how it changes the scope, agree on a new price and timeline, and only then continue. The client never finds out about an overrun after the fact.
Why is the estimate broken down by module?
The breakdown shows what each part of the project costs. If the total is above expectations, you can deliberately remove or postpone individual modules.
How often will I see progress?
We work in one-to-two-week iterations and at the end of each one show a working product in a browser or on a device, not slides.
What is discovery in software development?
It is the stage of understanding the task before estimating it. Its output is a document with the task description, constraints and criteria for a finished result, which becomes the basis of the estimate.