On the first consultation we usually hear one of two sentences. Either: "we got a quote for twenty thousand and three months, so we shelved it". Or: "a programmer we know built it for us after hours, it ran for six months, then he changed jobs". Both say the same thing: for small and medium-sized businesses, automation has so far been either too expensive or too cheap to rely on.
Hardly anyone writes about prices openly, so I will. Below is what we see in the quotes clients bring us, freelancer rates from the market, and our own numbers - the same ones we put in our proposals. The "competitor" figures are ranges from those conversations, not the price list of any particular company.
What it looked like just a few years ago
A classic software house prices an integration like any other project: analysis, requirements document, architecture design, development, testing, deployment, and at every stage a person who coordinates it. Each of those steps makes sense. The problem is that for a Subiekt-Allegro integration or a chatbot on a website, those steps cost more than the work itself.
In the quotes clients bring to our consultations, an integration of medium complexity - for example, orders from two channels into Subiekt with invoices and stock levels - costs PLN 20,000 net and up and takes about three months. Hourly rates in those proposals are PLN 150-250 net, and on top of the development itself there is 30-40% for project management, meetings and documentation.
For a company that retypes 500 orders a month, that is not an absurd amount - we did the math in the previous post, manual work costs more. But for a company that needs five such improvements, twenty thousand for each one kills the topic before it starts.
What freelancers charge
The second route is a freelancer. Rates on the Polish market are usually PLN 80-200 net per hour, depending on experience. The same integration as above comes to PLN 8,000-15,000 and 4-8 weeks with a good freelancer, because the whole coordination layer drops out. On paper, it is half the price.
The catch is not in the price but in what the price does not include:
- Warranty. Usually none, or verbal. When Allegro changes its API after three months, the fix is a new job - if the contractor has time.
- Monitoring. You find out the integration has stopped from a customer who did not get an invoice. Nobody looks at the logs, because nobody collects them.
- Continuity. One person, one laptop. Holiday, illness, a full-time corporate job - and the company has a system nobody knows how to touch.
- Code and documentation. They often stay on the contractor's computer. The next developer starts from scratch, because that is cheaper than understanding someone else's work.
- Error handling. The most common saving. An automation stitched together in Make or n8n works as long as everything goes to plan. The first unusual case slips through without a trace.
Cheap, fast, good: pick two
IT services have had the "project triangle" for years: out of three qualities - cheap, fast, good - you get at most two. Cheap and fast comes out sloppy. Cheap and good takes forever. Fast and good costs. Both routes from the previous sections sit squarely in that triangle: the software house picks "good and fast" and charges for it, the freelancer picks "cheap and fast" and hands it over without a warranty.
On the left you can check it yourself - switching on the third quality turns off one of the other two. On the right is what we do.
- Elsewhere
Pick two
Click a corner to switch it on or off.
Cheap and fast, so no “good”
Something for yesterday, for pennies. Usually no error handling, no documentation and nobody to fix it later. The fixes cost more than the project.
- With us
One switch
Turns on all three at once.
All three at once
Not because we broke the triangle. We changed what costs money inside it: we write code with AI, assemble from ready-made blocks, with no layer that doesn't write code.
The triangle is not a law of physics. It describes a company where cost means developer and coordinator hours, and time means the queue for those hours. If what costs money changes, the layout changes too. Where all three come from at once in our case, I explain in the section "Where the difference comes from"; first, the numbers.
What it costs with us
The same project that a software house proposal lists at PLN 20,000 and a quarter costs about PLN 6,000 net with us and takes four weeks. Smaller integrations - one channel, one type of document - we close in 2-3 weeks. Not because we skip stages, but because we do some of them differently.
| Software house | Freelancer | PRODAUT | |
|---|---|---|---|
| Price (net) | from PLN 20,000 | PLN 8,000-15,000 | approx. PLN 6,000 |
| Time to production | approx. 3 months | 4-8 weeks | 4 weeks |
| Warranty | per contract | usually none | 3 months |
| Error monitoring | extra charge | none | included |
| Code and documentation | per contract | varies | yours once paid |
| Payment | deposit + milestones | varies | 40% at start, 60% on acceptance |
| Subscription | often | none | none |
Scroll the table sideways
- instead of PLN 20,000 for the same scope
- PLN 6,000
- instead of 3 months to production
- 4 weeks
- warranty, regardless of support plan
- 3 months
Where the difference comes from
Not from quality, and I want to say that clearly, because "cheaper" in IT services sounds like "sloppy". The difference comes from four things that have changed in the last two years, and from the fact that we built the whole company around them.
- 01Coding with AI, for real. We write code with language models - not "paste it into a chat", but agents with access to the repository, the Sfera documentation and the tests. Things that took a day take an hour. Review and architecture are still ours, because that is where AI makes the most expensive mistakes.
- 02Ready-made building blocks from previous projects. After 27 deployments we have proven modules: logging into Subiekt via Sfera, handling orders from Allegro and Amazon, issuing invoices with per-country VAT. Each time we assemble them for the client, but we do not write from scratch.
- 03Our own infrastructure. Error monitoring, a workflow orchestrator, repositories and a test server run on our side and are included in the price. A software house bills these as separate line items; a freelancer usually does not have them at all.
- 04No layer that does not write code. You talk to the person who builds your integration. There is no account manager, project manager or analyst passing notes to each other - and they are not in the price either.
A quarter for the integration was not development time. It was time spent waiting for meetings.
Small automations: we do not charge much for them
Not every process is a four-week integration. Most companies have a dozen or so small things: an email attachment should go into a folder and a spreadsheet, the sales report should send itself on Monday morning, a new lead from the form should land in the CRM with a push notification. Each one is an hour a week; together, a full-time job.
We build things like that in one or two days and price them proportionally: a small automation is usually a few hundred to about PLN 2,000 net, with the same error handling and monitoring as in a big project. There is no minimum order value. It often pays to bundle several of these into one package and do them in one go - the unit price drops, because we do the audit and the setup once.
What exactly you get for that PLN 6,000
So that "cheaper and better" is not just a slogan, here is what is included in the price of every deployment:
- an audit document: architecture, scope, price and deadline, before you pay for the implementation,
- a working integration in production, with exception handling and logs you can actually read,
- error monitoring on our side - we usually know about a failure before you do,
- code in a repository and documentation, which are yours once paid,
- a 3 months warranty on what we built, regardless of the support plan,
- a reply within 4h on business days, from the person who did the implementation.
Examples from recent months are below the post. VAT invoices for five Amazon EU marketplaces went into production after three weeks, together with a security review. A household appliances wholesaler saves about ~180h of manual work a month after an implementation run in 2-3 week stages. A chatbot for a solar energy company was up in two weeks.
How we calculate the price
We do not have a price list in the sense of "Allegro integration: PLN X", because two companies with the same Subiekt have different numbering, warehouses and exceptions. What we do have is a fixed process that leaves no surprises:
- 01Free consultation (30 minutes). Ends with an indicative price range. If the project does not make economic sense, we say so at this stage.
- 02Process audit (PLN 699 net). You get a document with the architecture, scope, exact price and deadline. The audit fee is credited in full against the implementation price, so if you go ahead, it is free.
- 03Implementation. 40% at start, 60% on acceptance. Larger projects are split into 2-3 week stages, each with a working piece in production.
- 04After acceptance. Warranty and, if you want it, support tailored to real needs. No platform subscription - you pay once.
The price from the audit is the final price. If the scope turns out to grow along the way, we price the change separately before we do it, not on the final invoice.
