Scope in one document, estimation in another, and the proposal in a third. Add a few emails, several spreadsheet versions, and one last-minute scope change — and it becomes difficult to know which number is still correct.
For many software agencies, the presales process still depends on disconnected tools. Scope is described in a document, hours are calculated in a spreadsheet, and the client receives a proposal assembled separately.
Apropo connects these stages through one structured project model. Scope, worktypes, estimates, rates, visibility settings, and proposal versions remain connected as the project evolves.
Where the Problem Starts
The same situation appears repeatedly in software agencies: a new inquiry arrives, the team spends days breaking it down, an estimate is prepared, and a proposal is sent to the client.
Then the client asks:
- What happens if we remove this module?
- How much does it cost to add an integration?
- Can we see the estimate in days instead of hours?
- Can we compare an MVP version with the full scope?
With separate spreadsheets and proposal documents, every answer creates another manual update. Someone has to change the scope, recalculate the estimate, update the pricing, revise the proposal, and make sure the client is looking at the correct version.
The problem is not that spreadsheets are incapable of calculating numbers. The problem is that the scope, estimate, and proposal are separate sources of truth.
Why a Structured Workflow Matters
One Scope, Not Three Versions of It
A software project scope is easier to estimate when it is represented as a hierarchy:
- sections,
- modules,
- features,
- tasks,
- worktypes,
- estimates,
- descriptions, and
- visibility settings.
This structure makes the scope more than a document. It becomes data that can be changed, validated, estimated, priced, and rendered into a client-facing proposal.
In Apropo, a change to a project element can remain connected to the corresponding estimate and proposal view. The team does not need to recreate the entire document every time the scope changes.
Estimates Based on Worktypes and Rates
A project can contain different worktypes such as Backend, Frontend, QA, Project Management, DevOps, or Business Analysis. Each worktype may have its own estimate and rate.
Apropo’s company Rate Card supports:
- company-level worktypes,
- cost rates,
- sales rates,
- role-specific overrides,
- currencies.
This gives agencies a more consistent starting point than estimating every proposal from a blank spreadsheet.
The result is not an estimate generated by a black box. The team still decides what belongs in scope and reviews the numbers. Apropo makes the relationship between scope, effort, and price visible and easier to maintain.
How to Automate the Workflow
Step 1: Turn the Brief into a Project Structure
Start with the client’s requirements and convert them into a structured project outline.
Instead of keeping “reporting module” as one line in a document, break it into meaningful parts:
- dashboard,
- XLSX export,
- PDF report,
- API export,
- permissions,
- testing, and
- deployment tasks.
Each element can have its own description, worktype, and estimate. This gives the team enough detail to discuss scope without forcing the client to read an internal technical specification.
For AI-assisted presales work, Apropo can initialize a draft project from structured Markdown. The draft is parsed into a project hierarchy and can then be reviewed before it becomes a client-facing proposal.
Step 2: Add Worktypes and Estimates
Once the structure exists, assign the worktypes needed to deliver each part of the project.
For example, a task may require:
- 12 hours of Backend work,
- 8 hours of Frontend work,
- 4 hours of QA, and
- 2 hours of Project Management.
Apropo stores these estimates within the project structure. Estimates can be read and updated at the level of individual nodes and worktypes instead of being maintained only in a separate summary spreadsheet.
The project can also use average values or min/average/max estimation modes, depending on how the agency communicates uncertainty to clients.
Step 3: Apply Company or Project Rates
After effort is defined, apply the relevant financial model.
Apropo supports company-level rates as well as project-specific rates. Rates can be applied to a project structure together with the project currency, while preserving the underlying scope and worktype estimates.
This makes it possible to separate:
- delivery cost,
- sales price,
- role-specific rates,
- project currency, and
- estimate presentation.
The same structure can therefore support internal planning and client-facing pricing without copying totals between tools.
Step 4: Generate the Proposal from the Same Structure
A proposal should be a presentation of the estimate, not a second manually maintained version of it.
Apropo generates a shareable proposal view from the project structure. The team can control which sections, modules, features, and tasks are visible to the client. Internal descriptions and delivery details do not have to be exposed in the same way as client-facing scope.
Proposal versions make it possible to maintain different variants of the scope, such as:
- MVP,
- recommended scope,
- full implementation,
- optional integrations, or
- a revised version after a change request.
The client receives a proposal link generated from the selected version rather than a static document that immediately becomes outdated.
Step 5: Handle Scope Changes as Structured Updates
Scope changes are normal. The expensive part is losing control of their impact.
In Apropo, project structure nodes can be updated, enabled, disabled, added, or removed through the application and API workflows. Their estimates, worktypes, descriptions, and visibility can be managed as part of the same project model.
This means a change request can follow a predictable path:
- update the affected structure,
- adjust the relevant worktype estimates,
- apply the correct rates,
- review the new totals,
- publish the next proposal version.
The system also uses version information and optimistic locking to prevent one user from silently overwriting another user’s recent change.
That matters when sales, delivery, and management are working on the same proposal at the same time.
Step 6: Use Existing Data and Historical Signals
Most agencies already have useful estimation data. It may be stored in previous projects, spreadsheets, exports, or internal libraries.
Apropo can work with structured project data and existing spreadsheet-based workflows, while also providing CSV/XLSX exports for analysis and reporting. Historical project estimates can be used as a reference when building or refining company worktypes and rates.
The platform also supports historical anomaly searches and project estimate statistics. These capabilities help teams identify unusual estimates and compare current planning with previous project data.
This is a more practical form of continuous improvement than expecting an algorithm to automatically know whether an estimate is correct.
Where Apropo Fits
Apropo connects the main parts of the software presales workflow:
- AI-assisted draft creation from structured requirements,
- hierarchical project scoping,
- worktype-based estimates,
- company and project rate cards,
- cost and sales pricing,
- configurable estimate presentation,
- proposal versions,
- client-facing share links,
- scope visibility controls,
- API and MCP access for automation,
- historical estimate analysis, and
- Jira-related delivery integration.
The important point is not that every agency must abandon spreadsheets immediately. Existing estimates and operational tools can remain part of the workflow where they are useful.
The difference is that the central project structure becomes the place where scope and estimate stay connected.
What This Changes for a Software Agency
A connected estimation workflow gives the team a faster answer to the questions that matter during presales:
- What exactly is included?
- Which worktypes are involved?
- What is the expected effort?
- How does the effort translate into price?
- What changes if one part of the scope is removed?
- Which version did the client actually receive?
Instead of discussing spreadsheet formulas, the team can discuss scope, assumptions, risk, and value.
That improves more than speed. It also makes estimates easier to review, proposals easier to revise, and changes easier to explain to the client.
Summary
Automating software project estimation does not mean removing judgment from the process. It means putting judgment into a structure that can be reused and updated.
The practical workflow is:
- structure the requirements,
- assign worktypes,
- add estimates,
- apply rates and currency,
- generate a proposal,
- update the structure when the scope changes, and
- use historical data to improve future estimates.
With Apropo, scope, estimates, pricing, and proposals can remain part of one connected project model instead of drifting across separate files.
That is the foundation for a more reliable presales process — one where the answer to “what changes if we add this?” is available while the conversation is still happening.