Quotation management software: it goes out after a week, and then nobody calls back

The owner of a windows and solar shading company near Treviso, thirty-eight employees and 7.2 million euros in revenue, has a habit everyone in the office knows: on Monday morning she opens the "Quotes in progress" folder and counts. She finds forty. Some went out two weeks ago, others are still a Word draft marked "to finish", and for a dozen nobody remembers whether the customer ever replied. The main supplier's price list changed in June, and the one in the spreadsheet, on some rows, is still the one from March.

Here you will find what "quotation management software" really means and what it is not, the number that tells you whether you need it or whether a tidy spreadsheet is enough, the calculation of what handwritten quotes cost you every year, three calculations written in code that you can redo with your own data, and the threshold above which a custom piece pays for itself. The case that follows is a typical one, reconstructed from situations I have seen in companies that sell by quotation, with rounded numbers.

What quotation management software is, and what it is not

The search "quotation management software" gathers very different products, and whoever buys the wrong one finds out when quotes keep going out late. It is worth separating them straight away.

The first is the document generator: a program that takes a template, fills in the customer's details and produces a tidy PDF. It solves layout, and layout is the cheapest part of the problem. If your quote is already beautiful and your trouble is another one, this tool gives you a more elegant trouble.

The second is the product and price configurator, what the industry calls CPQ, from configure, price, quote. It is needed when the product has many variants and technical rules: this window with that glass does not fit that size, this motor needs that power supply. It is powerful and expensive, and it makes sense when the rules are many and fixed. For an SME that sells jobs that differ from one another, it is usually a cannon for a mosquito.

The third is the quotes module of the accounting system or of the CRM: it makes the quote inside the program that already knows customers, items and price lists. It is the most natural road, and it works as long as the way you quote resembles the one the module was designed for.

The fourth, and the one that matters to whoever is reading, is the set of rules and memory around the quote: where the request comes from, who takes it on, which price list is valid today, which minimum margin you do not go below, when you call the customer back, what happened afterwards. This is not a document. It is a process, and a process has a time, a cost and an outcome that can be measured.

Quote, offer, order: three words that carry weight in software

In everyday language they are synonyms, but in the system they are three moments with different rules. The request is what the customer asks for, sometimes in two lines of email, sometimes with a floor plan. The quote is your answer with price, terms and validity. The order is its acceptance, and from there the work enters another world: the job, which I wrote about in the article on job costing software.

The point where companies lose the most money is the interval between request and quote, and the one between quote and order. In the middle nobody is working badly: there is a handover that nobody has designed. The customer does not see your office, only whether you receive the request and how long you take to answer.

What it must be able to do, one line per function

A useful system holds five things together: the request with its data, the real and up-to-date price list with its pricing rules, the document that comes out, the follow-up after sending and the final outcome, whether an order or a no. Every program on the market does one or two of these well. Almost none keeps all five in the same place, and that is where the Monday morning folder comes from.

Why the quote goes out late without anyone noticing

At the Treviso company nobody was doing their job badly. The secretary sorted the requests, the technicians did the site visits, the owner checked the prices before signing. Every piece worked. What did not work was the time that passed between a request and the day the customer received a number.

We measured it over a year of requests. A typical request arrived on Monday by email or phone. The next day someone read it and assigned it. On the third day there was the site visit for measurements. On the fourth the price was confirmed with the supplier, because nobody trusted the price list in the sheet. On the fifth the document was compiled, on the sixth the owner signed it and on the seventh it went out. Seven working days, in the normal case. On average it was 6.4, with a tail of quotes that went past ten.

Seven days are a problem for a precise reason: whoever asks for a quote for windows asks for at least three, and most decide with the first one that answers seriously. The customer is not waiting for you. They are comparing, and every day of delay is a day in which someone else has already sent them a number.

The three things hidden in the seven days

The first is the invisible queue. Requests arrive from four places: the company mailbox, the sales reps' phones, the website form, WhatsApp messages. There is no single list, so nobody knows how many requests are waiting. A request that arrived on the phone of a sales rep on holiday can sit for ten days without there being a single place where it shows.

The second is the price list that is not the price list. Purchase prices change when the supplier changes, and the spreadsheet changes when someone remembers. In between there is a week, or two months, in which the quote is made with a price that no longer exists. The sensible reaction is to phone the supplier every time, and it costs a day.

The third is the quote that goes out and then vanishes. The email leaves, the file moves to the "sent" status, and from that moment nobody has the job of calling back. The customer waits for a sign that does not arrive, reads the silence as lack of interest and signs with whoever made themselves heard. In the Treviso case 36 per cent of quotes received no second contact within ten days of sending.

All three are visible in a day if the data is in one place, and visible in a year if the data lives in the heads of five people. This is the difference a quotation management system must produce, and the reason the word that matters is not "management" but timeliness.

Private customers, companies and public clients: where the problem changes

With private customers response time weighs almost more than price. The homeowner who renovates asks for three quotes in one afternoon, and the first credible one has an enormous advantage. The risk is slowness.

With companies the risk is the version. A building firm asks for a quote, then changes it four times because the project changes, and if there is no place where each revision stays linked to the previous one, you get lost. The right number is in the quote from three versions ago, and nobody finds it.

With public clients the quote is formal and deadlines are rigid. Here the loss is rarer but more serious: a document past its deadline cannot be recovered, and a wrong price becomes a contractual bond. For the contracts that follow, the discussion in contract management software applies, with dates and clauses kept in the system and not in a folder.

The real calculation: what a handwritten quote costs every year

Before talking about software it is worth calculating today's situation. In the Treviso case there were five items. I give them with the method, so you can redo them with your own numbers. I left out the cost of site visits and technical choices: that is real work, and no program does it in your place.

The premises are few. The company sent 1,600 quotes a year, about 133 a month, and closed 25 per cent of them: 400 orders of 18,000 euros on average, which make the 7.2 million euros of revenue. The gross margin on an average order was 28 per cent, about 5,000 euros. An hour of office time cost 36 euros, all included.

The avoidable compilation hours. Compiling a quote took two and a half hours on average: opening the latest similar one, checking the price list, calculating in Excel, laying out in Word, exporting the PDF, writing the email. With the data in one place and a template that calculates, one hour was enough, leaving the technical choice. That is 1.5 hours saved across 1,600 quotes, 2,400 hours, which at 36 euros make about 86,000 euros a year.

Quotes with no follow-up. 36 per cent of quotes, 576 out of 1,600, received no contact after sending. They closed 19 per cent. Those followed up with at least a second contact closed 28. The nine-point difference is not all due to the callback, because people call back more readily whoever seems interested. I took only a quarter of it, two and a half points: on 576 quotes that is 14 more orders, which at 5,000 euros of margin make about 70,000 euros a year.

Quotes sent late. 30 per cent of quotes, 480, went out within two working days and closed 34 per cent. Another 32 per cent, 512, went out between three and seven days and closed 26. 38 per cent, 608, went out after more than seven days and closed 17. Here too the difference is not all caused by the delay: the slowest quotes are also the most complicated. I counted only two points of recovery on 608: 12 orders, about 60,000 euros a year.

Price list and calculation errors. In a sample check, 6 per cent of quotes, 96 a year, had a price error: an old price list, a forgotten row, a discount applied twice. Customers, naturally, accept the errors that favour them: 24 orders were accepted at a price that was too low, with an average loss of 1,100 euros. That is about 26,000 euros a year.

Searching for history. Five people, three sales reps and two from the office, lost on average two hours a week looking for "what price did we give that customer", finding the latest version and rebuilding the story of a negotiation. Two hours for forty-six weeks for five people make 460 hours, which at 36 euros are about 17,000 euros.

The total is about 259,000 euros a year, 3.6 per cent of revenue, in a company with an operating margin of 6 per cent. Put another way: more than half of the profit went in the way quotes were born and followed up, not in the price or the quality of the windows.

Two honest warnings. The first: the items on delay and follow-up are missed earnings, not accounting losses, and they partly overlap, because a slow quote is often also a quote with no follow-up. That is why I took prudent recoveries, a small fraction of the observed difference. The second: the hours item is the most solid, because it is measured with a stopwatch.

Your calculation will differ, but the items are almost always these five. If the total, redone with your numbers, is below 1 per cent of revenue, quotation management software is not your priority. If it exceeds 2, it almost certainly is, even if nobody in the company calls it that.

How to redo the calculation in an afternoon

You need four data points, and almost all of them are in the sent mail. The first is the number of quotes in the last year, counting emails with the PDF attached. The second is the number of orders and their average value, which accounting knows. The third is compilation time: have three people time five real quotes, without telling them it is a test. The fourth is the average gross margin, which is the one your accountant uses.

With these four data points the items calculate themselves. No analysis is needed: what is needed is honesty about the fact that the real time is almost always double what you think.

The number that decides: how long you take to answer, and how many quotes are left alone

The calculation of the five items tells you how much you lose. It does not tell you whether software will make you recover that money, because part of the losses depends on commercial decisions that no program takes in your place. The number that says so is another one, and I call it response time: the average, weighted by the amount of the quotes, of the working days between the arrival of the request and the sending of the quote to the customer.

The thresholds I use are four. Below two days the situation is under control: a well kept sheet is enough, and maybe not even that. Between two and five the problem is one of method: the work is the same but arrives in scattered order, and before software you need to decide who takes on what and in how long. Between five and ten a system that calculates on its own pays for itself, because the delay is structural and no discipline removes it. Above ten days you are losing customers before even answering: the quote arrives when the decision has already been made.

At the Treviso company the response time was 6.4 days, in the band where a system pays for itself. And the distribution said more than the average: the highest value quotes, the complex ones with three or four types of window, were the slowest, and arrived on average after nine days.

The second number: how many quotes are left alone

Alongside response time I measure a second one: the percentage of quotes that receive no contact within ten days of sending. It is the measure of follow-up, and it is worth as much as the first. Below 10 per cent you are doing well. Between 10 and 25 there is a gap in method. Above 25 the quote, after sending, belongs to nobody. In Treviso it was 36.

The two numbers describe two different points of the same funnel. The first says how long you take to introduce yourself, the second whether you still show up afterwards. You can have one good and the other bad, and the remedies differ: in the first case you work on the price list and the templates, in the second on a list of callbacks that someone looks at every morning.

How to calculate them with the data you have

You do not need a new system for the first measurement. You need two tables: one with the arrival date of each request, one with the sending date of each quote, and a list of subsequent contacts. If they do not exist, they are rebuilt from the mail: the date of the customer's first email and the date of the email with the PDF attached. For working days you need a calendar with holidays set to zero. With this data the measurement is a query.

-- Response time and quotes without follow-up, last twelve months.
-- Calendario(Giorno date, Lavorativo bit): one row per day, holidays and bridge days set to zero.
-- Contatti(IdPreventivo, DataContatto): calls, emails and visits after sending.
WITH Base AS (
    SELECT p.IdPreventivo,
           p.Importo,
           lav.GiorniLavorativi,
           CASE WHEN EXISTS (SELECT 1
                             FROM Contatti AS c
                             WHERE c.IdPreventivo = p.IdPreventivo
                               AND c.DataContatto >  p.DataInvio
                               AND c.DataContatto <= DATEADD(day, 10, p.DataInvio))
                THEN 0 ELSE 1 END AS SenzaSeguito
    FROM Preventivi AS p
    JOIN Richieste AS r ON r.IdRichiesta = p.IdRichiesta
    CROSS APPLY (SELECT COUNT(*) AS GiorniLavorativi
                 FROM Calendario AS g
                 WHERE g.Lavorativo = 1
                   AND g.Giorno >  CAST(r.DataRichiesta AS date)
                   AND g.Giorno <= CAST(p.DataInvio AS date)) AS lav
    WHERE p.DataInvio >= DATEADD(month, -12, CAST(GETDATE() AS date))
      AND p.DataInvio <  DATEADD(day, -10, CAST(GETDATE() AS date))  -- only quotes with ten days of history
)
SELECT COUNT(*) AS PreventiviInviati,
       CAST(AVG(1.0 * GiorniLavorativi) AS decimal(5, 1)) AS TempoRispostaMedio,
       CAST(SUM(1.0 * GiorniLavorativi * Importo) / NULLIF(SUM(Importo), 0) AS decimal(5, 1)) AS TempoRispostaPesato,
       CAST(100.0 * SUM(SenzaSeguito) / COUNT(*) AS decimal(5, 1)) AS PercentualeSenzaSeguito
FROM Base;

The query returns four values: how many quotes, the average time, the time weighted by amount and the percentage without follow-up. Two warnings. The first: if the arrival date of the request was never written down anywhere, the measurement is already a finding, and a bad one, because it means nobody controls response time. The second: count the date the request arrived, not the one on which someone opened it. They are different days, and the first is the one the customer sees.

Price list, discounts and minimum margin: the calculation nobody does the same way twice

Almost all the value of quotation management software sits in one function: putting side by side, for each line of the quote, three numbers that today sit in three places. The purchase cost valid today, the price the customer will see and the margin that remains. If the third falls below a threshold, someone must know before the document goes out, not at the end of the month.

The part that seems trivial, and is not, is the validity of the price list. A purchase price has a start date and sometimes an end date. Today's quote uses today's price, the one from three months ago used the price of the time, and if the customer accepts after thirty days, the price you declared to them counts. A spreadsheet with a single "price" column cannot hold these things, and that is why mistakes happen.

A calculation you write in an hour

Here is the core in C#, with minimal types. It finds the price valid at the quote date, applies the markup and the requested discount, and returns the margin with the warnings the signer needs. The system never decides in place of the person: it flags.

// Pricing one quote line: price list valid at the date, markup, discount, minimum margin.
public sealed record VoceListino(string Codice, decimal CostoAcquisto, DateOnly ValidoDal, DateOnly? ValidoAl);

public sealed record RigaRichiesta(string Codice, decimal Quantita, decimal ScontoPercentuale);

public sealed record RigaPreventivo(
    string Codice,
    decimal Quantita,
    decimal PrezzoUnitario,
    decimal MarginePercentuale,
    IReadOnlyList<string> Avvisi);

public sealed class Prezzatore
{
    private readonly IReadOnlyList<VoceListino> _listino;
    private readonly decimal _ricarico;
    private readonly decimal _margineMinimo;
    private readonly int _giorniMassimiListino;

    public Prezzatore(IReadOnlyList<VoceListino> listino, decimal ricarico,
                      decimal margineMinimoPercentuale, int giorniMassimiListino = 90)
    {
        _listino = listino;
        _ricarico = ricarico;
        _margineMinimo = margineMinimoPercentuale;
        _giorniMassimiListino = giorniMassimiListino;
    }

    public RigaPreventivo Prezza(RigaRichiesta riga, DateOnly oggi)
    {
        var voce = _listino
            .Where(v => v.Codice == riga.Codice && v.ValidoDal <= oggi
                       && (v.ValidoAl is null || v.ValidoAl >= oggi))
            .OrderByDescending(v => v.ValidoDal)
            .FirstOrDefault();

        if (voce is null)
        {
            return new RigaPreventivo(riga.Codice, riga.Quantita, 0m, 0m,
                new[] { "No valid price list at this date: enter the price by hand." });
        }

        var avvisi = new List<string>();
        var eta = oggi.DayNumber - voce.ValidoDal.DayNumber;
        if (eta > _giorniMassimiListino)
        {
            avvisi.Add($"Price list is {eta} days old: confirm the cost with the supplier.");
        }

        var prezzo = Math.Round(voce.CostoAcquisto * _ricarico * (1 - riga.ScontoPercentuale / 100m), 2);
        var margine = prezzo == 0 ? 0m : Math.Round((prezzo - voce.CostoAcquisto) / prezzo * 100, 1);
        if (margine < _margineMinimo)
        {
            avvisi.Add($"Margin {margine}% below the minimum of {_margineMinimo}%: approval needed.");
        }

        return new RigaPreventivo(riga.Codice, riga.Quantita, prezzo, margine, avvisi);
    }
}

A French window with a purchase cost of 612 euros and a markup of 1.45 is sold at 887.40 euros, with a margin of 31 per cent. If the customer asks for a 12 per cent discount, the price drops to 780.91 euros and the margin to 21.6, below the minimum of 24 that the company has set itself. The system refuses nothing: it writes at the top of the line that the owner's approval is needed, and the owner decides in ten seconds, with the number in front of her, instead of finding out at the end of the month.

There is nothing sophisticated here, and that is exactly the point. The value is not in the formula: it is in the fact that the price list is a single one, that it has dates, and that the minimum margin rule is applied by a machine every time, and not by the memory of someone tired on a Friday afternoon.

The rules to write once and remember always

Every company that sells by quotation has five or six rules that move money: the markup per product family, the maximum discount a sales rep can give without asking, the margin below which approval is needed, the validity of the quote in days, the standard payment terms and when it is allowed to deviate. You do not need fifty parameters: you need these, written well, in a place where the system reads them and not in a file someone saved on the desktop. An afternoon of work, done once.

Whoever also runs a warehouse adds one more line: availability. It is not mandatory, but a quote that promises delivery in two weeks for an item with a six week lead time is the most common source of disputes, and connecting the two systems is worth what is written in the article on warehouse management software.

After sending: how to follow a quote without depending on memory

The quote does not end when it goes out. It ends when the customer says yes, no, or stops replying. In between there is the work that companies do worst, because it is work without a deadline. Nobody calls you to tell you that you forgot to call a customer back.

The method I propose is simple. Every quote has a callback calendar set when it goes out: the first after three days, to know whether it arrived and whether there are questions; the second after ten, to understand where the decision stands; the third after twenty-one, to close with a yes, a no or a new date. Every morning the system shows the list of callbacks planned for that day, ordered by importance.

The important word is ordered. A list of forty callbacks nobody does, a list of eight in which the first is worth twenty-five thousand euros everybody does. The order comes from a simple rule: the amount counts, and counts more if the customer has opened the document, because an opened quote is a read quote.

A morning list you write in half an hour

// Today's callback list: three contacts planned at 3, 10 and 21 days from sending.
public sealed record PreventivoAperto(
    string Id, string Cliente, decimal Importo, DateOnly DataInvio,
    int ContattiDopoInvio, bool Visualizzato);

public sealed record DaRichiamare(
    string Id, string Cliente, decimal Importo, int GiorniDallInvio, decimal Priorita, string Motivo);

public static class Seguito
{
    private static readonly int[] GiorniPrevisti = { 3, 10, 21 };

    public static IReadOnlyList<DaRichiamare> Oggi(
        IEnumerable<PreventivoAperto> aperti, DateOnly oggi, int giorniValidita = 30)
    {
        var elenco = new List<DaRichiamare>();

        foreach (var p in aperti)
        {
            var giorni = oggi.DayNumber - p.DataInvio.DayNumber;
            if (giorni > giorniValidita || p.ContattiDopoInvio >= GiorniPrevisti.Length)
            {
                continue; // expired, or already followed three times: out of the morning list
            }

            var scadenza = GiorniPrevisti[p.ContattiDopoInvio];
            if (giorni < scadenza)
            {
                continue; // not the time yet
            }

            // Weighs more whoever opened the document and whoever has waited longer past the due day.
            var peso = (p.Visualizzato ? 1.3m : 1.0m) * (1 + (giorni - scadenza) * 0.02m);
            elenco.Add(new DaRichiamare(
                p.Id, p.Cliente, p.Importo, giorni, Math.Round(p.Importo * peso, 0),
                $"Contact {p.ContattiDopoInvio + 1} of {GiorniPrevisti.Length}, planned on day {scadenza}"
                + (p.Visualizzato ? ", document opened" : "")));
        }

        return elenco.OrderByDescending(d => d.Priorita).ToList();
    }
}

On forty-eight open quotes, on a Monday, the function puts twelve on the list. The first is a 31,000 euro quote for a nursery school, sent eleven days earlier, opened twice, with only one contact already made: high priority, because it is big, read and stalled. The last is a 2,400 euro balcony sent four days earlier and never opened. The system calls nobody. It tells the right person whom to call, and that is the thing a spreadsheet does not do.

The callback must not be an automatic message: customers read those as spam. It must be a person with a real sentence, perhaps prepared by a model, asking whether anything else is needed to decide. The difference between the two is felt immediately.

Why follow-up is also the CRM's job

A good half of what is needed for follow-up is already in a CRM, if the company has a well kept one: customers, contacts, conversation history, reminders. I wrote about it in the article on CRM software. The reason it often is not enough is that the CRM knows the customer but not the quote: it does not know which price list was valid, which margin, which version is the latest. The quotation system and the CRM must exchange the outcome, and that is all. Neither must become the other.

How quotation management software should run: from request to order

The question I am asked most often is whether it should be a product or a new system. First it is worth understanding what must happen, because the flow is the same whichever road you choose.

Every request enters a single list. Email, phone, website form, WhatsApp: whatever the channel, the request ends up in one place with an arrival date and an owner. You do not need to eliminate channels, you need everyone to write in the same list. At the Treviso company a dedicated mailbox and a three-field form for phone calls were enough.

The price list has dates. Every purchase price has a start and an end, and when a new price list arrives from the supplier it is loaded once, not remembered and changed in twenty cells. It is the point where you recover the most hours and avoid the most errors.

The quote is generated from a template. The lines come from the request and the price list, the margin calculates itself, the standard terms are already written. What remains for whoever prepares it is the part that takes craft: measurements, technical choice, notes for that customer.

Revisions stay linked. When the customer asks for a change, the quote becomes version two, and version one stays consultable. This way an old price is not sent by mistake, and you can show the customer what changed and by how much.

The callback calendar starts with sending. There is no choice to make: it starts on its own, and every morning whoever must call back sees the list. If someone is on holiday, the list passes to a colleague.

The outcome returns. An order, a no with the reason, a silence after three contacts. The reason for a no, chosen from a short list, is the most valuable data a company can collect: after six months it says whether you lose on price, on time or on trust.

The order passes to the job. When the quote turns into work, the data is not retyped: the lines, the prices and the promised margin become the basis of the job, and the actual margin is compared with that of the quote. It closes the circle, and it is the piece described for service companies in the article on management control software.

None of these steps requires changing the accounting or the invoicing. At the Treviso company the accounting system stayed the same. What changed was what sat in the middle: the folder of Word files and the price sheet.

What it must not do

A system of this kind must not make the quote more rigid than it is. Part of the craft lies in the exception: the long-standing customer who gets a favour price, the odd job that fits no category, the deviation born from a handshake. The system must allow all this, asking only that the deviation is written down with a name next to it. A program that prevents the exception will be bypassed within a week, and the folder of Word files will come back.

How much quotation management software costs: product, accounting module or custom

There are three roads, and the prices that follow are those I see in 2026 for Italian companies that sell by quotation, between three and thirty million euros in revenue.

The quoting product. There are programs designed for making quotes, with templates, price lists, e-signature and a minimum of follow-up. They usually cost between two and fifteen thousand euros a year, depending on users and features, with a setup between zero and ten thousand euros. They do the generic things well: tidy document, sending, signing. They do the particular things of your company less well: the dated price list, the margin rules, the link with your job.

The accounting module. The quotes module of the accounting system or of the CRM costs between five and twenty-five thousand euros in licences and configuration. It has the advantage of already knowing customers and items. It is designed for quotes that resemble an advance invoice, and this is felt when your quote has three versions, a site visit and a callback calendar.

The custom system. Here too two figures. A custom piece that sits alongside what you have, meaning dated price list, pricing and margin rules, document generation, callback calendar and links with the CRM and the job, costs between twenty-five and fifty-five thousand euros, plus fifteen or twenty per cent a year for maintenance. A complete system, with a configurator that knows the technical rules of the product, costs between eighty and one hundred and sixty thousand euros and is rarely needed below eight hundred quotes a year.

The threshold, with numbers

The most useful comparison is between staying with Word and Excel and building a custom piece. The cost of the piece is almost fixed, while the cost of the time you lose grows with the number of quotes.

With the Treviso numbers, the piece cost 46,000 euros, with maintenance of fifteen per cent, that is 6,900 euros a year. Over five years that makes 80,500 euros. Each quote prepared in one hour instead of two and a half saves 1.5 hours, that is 54 euros. Over five years each quote per year of volume is worth 270 euros. Counting time alone, the two roads cross at around three hundred quotes a year, twenty-five a month. Below that threshold a well made sheet and an hour of discipline are enough.

// How many quotes a year are needed for a custom piece to pay for itself in N years.
public static class Pareggio
{
    public static (int SoloTempo, int ConOrdiniRecuperati) Preventivi(
        decimal costoRealizzazione, decimal manutenzioneAnnuaPercentuale, int anni,
        decimal oreRisparmiate, decimal costoOra, decimal ordiniRecuperatiPerPreventivoAnno)
    {
        var costoTotale = costoRealizzazione * (1 + manutenzioneAnnuaPercentuale * anni);
        var risparmioTempo = oreRisparmiate * costoOra * anni;           // per each quote a year
        var risparmioOrdini = ordiniRecuperatiPerPreventivoAnno * anni;  // idem, in recovered margin

        return (
            (int)Math.Ceiling(costoTotale / risparmioTempo),
            (int)Math.Ceiling(costoTotale / (risparmioTempo + risparmioOrdini)));
    }
}

// Pareggio.Preventivi(46000m, 0.15m, 5, 1.5m, 36m, 98m)  =>  (299, 106)

And time alone is the smallest part of the calculation. At Treviso the orders recovered through callbacks, faster answers and corrected prices were worth about 98 euros for each quote per year: the 60,000, 70,000 and 26,000 euros from before, divided by 1,600 quotes, and prudent. Adding them, the threshold drops to about one hundred quotes a year, fewer than nine a month. The custom piece, which cost 46,000 euros, paid for itself in eight months from the start of the project, counting the three of the plan.

The road I recommend in most cases is a mixed one: the accounting system or CRM you already have for customers, items and invoices, and a custom piece for what no product does well, meaning the dated price list, the margin rules, the callbacks and the outcome. If across the whole company there are fewer than a hundred quotes a year, you need neither: a good template, a callback sheet and an hour a week are enough.

The questions to ask whoever proposes a product

Five questions separate the products that solve the problem from those that move it.

Does the price list have dates? If an item's price is a single number, the quote from three months ago and today's will use the same one, and one of the two is wrong. Ask to see how a new price list is loaded and what happens to quotes already sent.

Who warns me if the margin falls below the minimum? If the rule is a free text field, nobody will ever warn you. Ask for a test with a fifteen per cent discount.

Where do I see the quotes nobody called back? If the program has no list for the day, follow-up will remain an intention. Ask to see the screen of a Monday morning.

How does the outcome pass to the CRM and the job? If each step is an export to do by hand, the data will drift apart within a month.

How does my data get out? A product that does not expose its data through a documented interface is another island, and the history of your prices and your noes is the last thing a company can afford to leave locked inside a supplier's program.

Artificial intelligence in quotation management software: where it helps and where it does not

Many 2026 products promise an assistant based on artificial intelligence. I have used language models every day in my work since 2023, and for those who make quotes I have seen three uses that pay off and one that does not.

The draft from the request. A model reads the customer's email or message and prepares the draft of the structured request: what they ask for, for which address, with which measurements if there are any, what is missing to answer. A person checks and completes. The work of reading and copying, which took the first half hour, becomes a two-minute check, and above all the request lands in the list with the right fields instead of in a mailbox.

The cover letter. The model writes the text that accompanies the quote, with the right tone for that customer and references to the conversation. The prices are those calculated from the price list, not written by the model. The signature is a person's.

The callback text. When the morning list says to call back a customer, the model proposes two sentences that take the last conversation into account: "I am writing to ask whether you managed to look at the proposal for the school, and whether you need me to send the glass datasheet". The person reads them, changes them and sends them.

What does not pay off, and here I am blunt, is the decision on the price. A language model does not know what your supplier charges today, how much margin you can afford with that customer, what the competitor offered. It can produce a plausible number, and a plausible wrong number is worse than no number. The price is decided by the price list with its rules, and if the price list is not enough it is decided by a person. The model prepares, the person decides.

There is a second limit, less visible. A model working on dirty data, meaning old price lists, confused versions and incomplete histories, produces wrong drafts with great confidence, and people stop trusting it in a day. That is why artificial intelligence should be added after the data, not before.

Where to start: the first release in ninety days

Whether you choose a product, the accounting module or a custom piece, the order in which things are done matters more than the choice. This is the plan I use for a company that sells by quotation, and it fits in ninety days.

The first two weeks: measurement. Response time and the percentage of quotes without follow-up are calculated, rebuilding the dates from the mail. Five real quotes are timed. The calculation of the five items is redone. At the end there is a number and a list of the biggest open quotes to call back immediately, which usually pays for the cost of the work on its own.

From the third to the sixth week: the single list and the price list. A mailbox and a form are opened for all requests, with an arrival date and an owner. The main supplier's price list is loaded with its dates, and the margin rules are written. You start from the product families that weigh most on revenue.

From the seventh to the tenth week: the document and the calculation. The quote template is switched on, taking lines from the price list and calculating the margin. Whoever prepares quotes uses it for a month in parallel with the old files, and results are compared line by line. It is the phase in which illusions are lost and trust is gained.

The last three weeks: follow-up and outcome. The callback calendar with the morning list is switched on, and whoever closes a quote is asked to note the reason for any no. From here on the data is born once.

The rest, from the draft of the request to the callback text, comes later, when the data is reliable. At the end of the ninety days the two numbers are measured again: it is the only way to know whether the project worked, and if it did not, to understand where to look.

What to ask of the person who builds it

If you choose the custom piece, three requests before starting. Ask that the two numbers, response time and quotes without follow-up, are calculated by the system from day one, so that the result is seen without a meeting. Ask that the price list and the rules can be changed by whoever works in the company, without going through whoever wrote the program. Ask that the data comes out in an open format, so that you are not held hostage even by whoever did it well.

If the number says it is not your problem

It may be that, once measured, response time is below two days, that someone does the callbacks and that the price list is kept in order. That is good news, and it is worth saying plainly: in that case a custom quotation management software is not what you need, and whoever tells you otherwise is selling you something.

In that case the bottleneck, if there is one, is almost always elsewhere. If you answer early and follow up well but close few orders, the problem is in the offer: in the price, the product or the way you tell it, and no software solves it. It is solved by talking to the customers who said no and asking why. If quotes are few and big, ten or twenty a year worth half a million each, you do not need a system: you need a person who follows them one by one, like a project.

And there is a case in which software is not the answer even with ugly numbers: when the delay does not depend on the tools but on the fact that only one person knows how to do the quote, the owner. There the problem is delegating, and a program helps you only if you have first written down, even on a sheet, how you reason when you set a price.

If you have read this far, you probably have the Monday morning folder in mind. Before looking at any demonstration, take the last ten quotes you sent and write down, for each, the day the request arrived and the day the number went out. Then look at how many received a phone call after sending. If the average exceeds five days, or more than one quote in four was left alone, you already have the answer. The rest is a project, not a product choice.

If you want a second look at your case, the way is to get in touch, and when the right solution is a piece built around the way you work, the same page also covers custom software. For the method used to read the margin of a whole company, from above, there is the article on management control software.