Custom software development means building an application designed exactly around your company's processes, rather than adapting your company to a generic product. The investment is worth it when off-the-shelf solutions hold you back, when your process is a competitive advantage, or when you want to sell software as a service. In this guide we cover project types, honest costs on the Romanian market in 2026, the end-to-end process and the traps to avoid.
We, the WebForge team, have been building custom software for Romanian companies for years — web applications, SaaS platforms and automations — exclusively on custom code (Next.js, React), not on templates or WordPress. We wrote this guide for the entrepreneur who is seriously considering a software investment and wants straight answers, not sales language. You can always check our services and our portfolio for concrete context.
What custom software means and how it differs from off-the-shelf solutions
Custom software is an application built from scratch for the specific needs of a single organization, while off-the-shelf solutions are generic, ready-made products sold by subscription to thousands of customers. The fundamental difference is not technical but about control: who decides what your software can and cannot do.
An off-the-shelf solution — a popular CRM, a subscription e-commerce platform, an invoicing tool — is quick to start with and cheap at first. You pay 20–200 EUR per month and get features tested by thousands of users. The problems appear over time:
- Your processes bend to the software, not the other way around. If your sales flow has a step the off-the-shelf product does not support, you either drop the step or improvise in Excel on the side.
- Costs grow with every user and every module. A 50 EUR/month subscription becomes 800 EUR/month at 20 users with premium modules. In 3–4 years you can exceed the cost of an application built for you.
- Your data and integrations depend on the vendor. If the platform changes its pricing, its API, or simply shuts down, your options are limited.
- You do not differentiate. Your competitor uses exactly the same tool, with exactly the same limits.
Custom software flips the equation: the upfront cost is higher, but the application does exactly what you need, you own it (if you sign the right contract — we will come back to that), and the marginal cost per user is close to zero.
Decision criteria: off-the-shelf or custom?
Our honest recommendation: do not build what you can buy off the shelf, if the shelf covers 90% of your needs. Build custom when you tick at least one of the criteria below:
- Your process is a competitive advantage. If the way you manage orders, logistics or customer relationships sets you apart, generic software flattens that edge.
- You have tried 2–3 off-the-shelf solutions and you still work in Excel on the side. This is the clearest practical signal: parallel Excel files are the symptom of software that does not fit.
- Licensing costs exceed or approach the cost of development. Do the math over 3–5 years, not over one month.
- You want to sell software, not just use it. Your own SaaS platform cannot, by definition, be bought off the shelf.
- You need integrations nobody offers. Legacy systems, industrial equipment, flows specific to the Romanian market (e-Factura, SAGA, local couriers).
There is also an underrated middle path: keep the off-the-shelf tools that work and build custom only the missing layer — a customer portal on top of your existing ERP, an automation between your CRM and invoicing. This is often the best investment-to-result ratio.
Types of custom software projects
The most common custom software projects for companies are internal web applications, SaaS platforms, customized CRM/ERP systems, customer portals and integrations between existing systems. Here is what each involves and who it makes sense for.
Business web applications
Applications used internally or by customers through a browser: order management, scheduling, quoting, reporting, approval workflows. They are the most common project type, because they solve the concrete pain of companies that have outgrown Excel and e-mail. A well-built web application runs on any device, requires no installation and is updated centrally. We covered the costs of this project type in our guide on how much a web application costs.
SaaS platforms
Software-as-a-Service: you build an application you sell by subscription to other companies or individuals. Here the software is no longer a tool — it is the product of your business. A SaaS project has extra requirements compared to an internal application: multi-tenant architecture (multiple customers on the same infrastructure, with isolated data), recurring billing, self-service onboarding, scalability. It is a category we work in intensively — see our SaaS platform development page — and one where we almost always recommend starting with an MVP: we explained why in our article on building an MVP.
Customized CRM and ERP systems
A custom CRM tracks exactly your sales pipeline, with your stages, fields and reports. A customized ERP (or, more realistically for SMEs, a "mini-ERP" covering the modules that matter) ties inventory, orders, production and invoicing into a single system. A note of honesty here: a complete ERP built from scratch is an enterprise project worth tens or hundreds of thousands of euros. For most Romanian companies, the pragmatic solution is a custom system covering 2–4 critical modules, integrated with what already exists.
Customer or partner portals
An authenticated space where your customers see their orders, contracts, invoices and work status, or submit requests. Portals dramatically reduce the volume of repetitive calls and e-mails ("what is the status of my order?") and raise the perception of professionalism. They are usually built on top of existing internal systems, so they are medium-complexity projects with high impact.
Integrations and automations
Not every project means a new application. Sometimes the most valuable investment is making existing systems talk to each other: the online store with inventory, the CRM with invoicing, website forms with an automated processing flow. In 2026, more and more of these automations also include AI components — automatic request classification, data extraction from documents, assisted replies — a field where we actively build solutions for our clients.
The end-to-end development process: from idea to live application
A custom software development project goes through seven stages: discovery, specifications, design, development, testing, launch and maintenance — in total, between 6 weeks and 6+ months, depending on complexity. Here is what concretely happens in each stage and how long it realistically takes.
1. Discovery (1–2 weeks)
The development team must understand your business before writing a line of code. In discovery discussions we clarify: what problem the software solves, who uses it, what processes it covers, what existing systems must be connected, what budget and time constraints exist. A vendor that skips this stage and sends you a quote 24 hours after a single phone call is guessing — and you pay for the guesswork.
2. Specifications (1–2 weeks)
The output of discovery turns into a specifications document: the feature list, user flows, business rules, prioritization (what goes into the first version, what waits for later). Good specifications are the cheapest cost-control tool there is: a feature clarified on paper costs an hour of discussion; the same feature clarified after being built wrong costs weeks.
3. UX/UI design (1–3 weeks)
Before development, the main screens are designed visually: wireframes for structure, then final design for the look. You validate on images, not on code — changes in this phase are fast and cheap. For simple internal applications, design can be lighter; for SaaS products competing on the market, it is a critical stage.
4. Development (4–16+ weeks)
The longest stage. Serious work is done iteratively: partial deliveries every 1–2 weeks, which you can test in a staging environment. Insist on this rhythm — if the vendor "disappears" for two months and promises to come back with everything done, the risk of surprises is at its maximum. At WebForge we build on a modern stack (Next.js, React, TypeScript), which means code any competent team can take over later — you are not locked in with us.
5. Testing (1–3 weeks, partly overlapping development)
Serious testing happens continuously, not just at the end: automated tests written alongside the code, plus functional testing of the real flows. The final stage includes acceptance testing done by you and your people — on data as close to reality as possible. Bugs found now cost hours; bugs found in production cost trust and money.
6. Launch (1 week)
Going to production: configuring servers, domain, certificates, migrating existing data (if needed), training users. We almost always recommend a gradual launch — first a small group of users, then everyone — instead of a "big bang".
7. Maintenance (ongoing)
Living software needs care: security updates, small fixes, adjustments as the business evolves. Budget realistically 10–20% of the project's initial cost, per year. A vendor that does not talk about maintenance from the quote stage is hiding part of your total cost.
How much custom software costs in Romania in 2026
On the Romanian market in 2026, a simple web application costs roughly 3,000–7,000 EUR, a medium-complexity project 10,000–30,000 EUR, and enterprise platforms start at 30,000 EUR; the usual hourly rates of Romanian teams are 30–50 EUR/hour. The ranges are honest but wide — because price is driven by feature complexity, not by labels.
| Project type | Indicative range (EUR) | Typical duration |
|---|---|---|
| Targeted automation / integration | 2,000 – 8,000 | 2–6 weeks |
| Simple web application / MVP | 3,000 – 7,000 | 4–8 weeks |
| Medium application (SaaS, customer portal, custom CRM) | 10,000 – 30,000 | 2–5 months |
| Enterprise platform / complex multi-module system | 30,000+ | 5–12+ months |
A few nuances that matter when comparing quotes:
- The hourly rate does not tell the whole story. A team at 45 EUR/h that delivers in 200 hours is cheaper than one at 30 EUR/h that needs 400 hours (plus another 100 for fixes).
- Ask for a feature-by-feature breakdown. A quote with a single final figure, with no detail, does not let you cut scope intelligently when the budget is tight.
- The total cost also includes what comes after launch. Hosting (from 20–100 EUR/month for most projects), third-party services (e-mail, payments, storage) and annual maintenance.
- The MVP is your budget's best friend. Almost any 30,000 EUR project contains an 8,000–12,000 EUR core that validates the idea. Details in our guide on building an MVP.
For a more granular analysis of pricing factors — authentication, payments, integrations, reporting — we wrote separately about how much a web application costs.
Want an honest estimate for your project, with a feature-by-feature breakdown and no obligations? Write to us on the contact page — we reply with concrete questions, not a guessed figure.
In-house team, agency or freelancer: who builds your software?
For most Romanian SMEs, a specialized agency is the optimal balance between cost, skills and continuity; an in-house team only makes sense once software becomes your core activity, and the right freelancer works for small, well-defined projects. Here is the comparison with no punches pulled — including the downsides of the option we ourselves represent.
The in-house team
Advantages: total control, deep knowledge of the business, permanent availability. Disadvantages: a single senior developer costs 4,000–7,000 EUR/month in Romania (full employer cost), and a serious project requires at least 2–3 roles (development, design, testing). Add the risk of departure — all the know-how in one person — and a recruitment time of 2–4 months. It makes sense when the software product is your business and you have a permanent workload.
The development agency
Advantages: a complete team from day one (developers, designer, project management), proven processes, continuity — if one person leaves, the project does not die. Honest disadvantages: you are one of several clients, so availability is not instant; the hourly rate is higher than a freelancer's; and quality varies enormously between agencies, so selection matters (see the red flags section). Typical cost on the Romanian market: 30–50 EUR/hour.
The freelancer
Advantages: lower cost (20–40 EUR/hour), direct communication, flexibility. Disadvantages: one person means one skill set — you rarely find a good backend developer, a good designer and a rigorous tester in the same person; availability depends on their other clients; and if they get sick or quit, the project freezes. Works well for projects under 5,000–8,000 EUR with a clear scope, or as an extension of an existing team.
How to write a good brief (and why it lowers your invoice)
A good brief describes the business problem, the users and the expected outcome — not the technical solution — and can cut the total cost by 20–30%, because it eliminates expensively paid assumptions. You do not need technical knowledge to write it. The structure we recommend to our clients:
- Business context: what the company does, how many people, what volumes (orders/month, active customers).
- The problem: what hurts today, concretely. "We lose 2 hours a day copying orders from e-mail into Excel" is infinitely more useful than "we want digitalization".
- The users: who will use the application and what each role must be able to do.
- The main flows: describe 3–5 scenarios in simple words, start to finish. "The customer submits the request, the agent approves it, the system generates the contract."
- Existing systems: what you use now (ERP, invoicing, online store) and what must be connected.
- Constraints: indicative budget, real deadline (if one exists), legal requirements (GDPR, e-Factura).
- The success criterion: how you will know in 6 months that the investment was worth it.
Two pages are enough. Do not be afraid to include your indicative budget: the fear that "they will quote exactly what I said" is smaller than the real risk of receiving quotes for a project three times larger or smaller than you can afford.
Red flags: warning signs with software vendors
The most dangerous signals from a vendor are the instant quote with no questions asked, your lack of access to the code, and a contract that says nothing about intellectual property. The full list, from our experience taking over projects from other vendors:
- A firm quote within 24 hours, with no discovery discussion. Nobody can honestly estimate what they have not understood.
- "Anything is possible, no project is too complicated." Serious vendors also say "no" — to unrealistic deadlines, to features that do not justify their cost.
- You get no access to the source code along the way. The code must live in a repository (GitHub, GitLab) you can access from week one, not "at the end, after the last payment".
- Demos only on their screen, never in an environment you can test yourself.
- 100% or mostly upfront payment. The normal arrangement is staged on deliverables: a reasonable advance, then installments tied to verifiable milestones.
- No verifiable project in the portfolio. Ask for live links and, ideally, the chance to talk to an existing client.
- Proprietary or exotic technologies "only theirs". If only they can work on that platform, they dictate the maintenance price, for life.
- Silence when you ask about maintenance and handover. A fair vendor explains from the start what happens if you part ways.
What to guarantee by contract: source code, intellectual property, maintenance
A software development contract must explicitly stipulate three things: that you receive the complete source code, that the economic copyright over the deliverables is assigned to you upon payment, and what the warranty and maintenance terms are. Without these clauses, "your software" can legally belong to the vendor.
The source code
The contract must provide access to the code repository throughout the project and a complete handover at the end: code, installation scripts, basic documentation, access to all accounts created in your name (hosting, domain, third-party services). Check in particular that the hosting and the domain are on your accounts, not the vendor's.
Intellectual property
Under Romanian law, copyright over code belongs by default to its creator unless the contract states otherwise. The essential clause: the economic rights over the deliverables developed specifically for the project are assigned to the client upon full payment. It is normal and acceptable for the vendor to retain the right to reuse generic components and open-source libraries — what matters is that your application, your business logic and your data are yours. Note: this is our practical experience, not legal advice — for large contracts, have a lawyer review the contract.
Warranty and maintenance
Healthy market practice: a warranty period of 1–3 months after launch, during which bugs (deviations from the specifications) are fixed for free, followed by an optional maintenance contract — either a monthly subscription or a bundle of hours. The important distinction the contract must make explicit: bug = free under warranty; new feature = paid development. Ambiguity here is the source of most vendor–client conflicts.
Common mistakes entrepreneurs make on their first software project
The most expensive mistakes are choosing purely on price, an inflated scope for the first version, and the absence of a project owner on the company's side. We list them all, because we have seen each of them cost real money:
- Choosing the cheapest quote without comparing what it contains. A 30% difference between quotes is almost always a difference in scope, quality or honesty — rarely one of efficiency.
- Wanting everything in version 1. Every "would be nice to have" feature delays the launch and makes the project more expensive. Launch the core, learn from real usage, extend based on data.
- Not assigning an internal owner. The vendor needs answers and decisions weekly. Without a designated decision-maker, every question waits for days and the project drifts.
- Changing requirements during development without accepting the impact. Changes are normal and healthy — but each one has a cost in time and money that must be discussed when the change is made, not at invoice time.
- Ignoring maintenance when calculating the investment. Unmaintained software becomes, within 2–3 years, a security vulnerability and a brake on the business.
- Not testing with real users before launch. The people who will use the application daily find problems in two hours that nobody else sees.
- Signing without intellectual property and handover clauses. See the previous section — it is the mistake with the most expensive long-term consequences.
Conclusion: how to move forward
Custom software is an investment, not an expense — but only if you start with a clear problem, the right vendor and the right contract. A three-step recap: write a two-page brief following the structure above; ask 2–3 vendors for itemized quotes and compare scope, not just final figures; check the red flags and the ownership clauses before signing.
If you want a second opinion or an honest estimate, we, the WebForge team, work exactly the way this guide describes: discovery before quoting, transparent prices broken down by feature, custom Next.js/React code handed over in full, and a contract assigning the rights to you. Check our services and the projects in our portfolio, then write to us on the contact page — the first discussion is free and comes with no obligations.
Frequently asked questions
How long does a custom software project take?
Roughly: 4–8 weeks for a simple application or an MVP, 2–5 months for a medium-complexity project (SaaS, customer portal, custom CRM) and 5–12+ months for enterprise platforms. The duration includes discovery, specifications and testing, not just writing code.
What is a realistic minimum budget for custom software in Romania?
On the Romanian market in 2026, serious custom application projects start at around 3,000 EUR for a simple, well-scoped application. Below this threshold, only targeted automations or extensions of existing systems are feasible. For details, see our guide on how much a web application costs.
Who owns the source code at the end?
It depends entirely on the contract. In the absence of an assignment clause, the rights remain by default with the developer. Explicitly require: repository access during the project, complete handover at the end, and assignment of the economic rights over the deliverables to you upon full payment.
Custom software or a subscription to an off-the-shelf solution?
Off-the-shelf if it covers at least 90% of your needs and your processes are standard. Custom software if your process is a competitive advantage, if you work in Excel "on the side" of your existing tools, or if you want to sell software as a product. Calculate subscription costs over 3–5 years before deciding.
Can I start with a small version and extend later?
Yes — and that is exactly what we recommend. An MVP (minimum viable product) with the functional core costs a fraction of the full vision and validates your idea with real users. We detailed the approach in our article on building an MVP.