// SOFTWARE FACTORY
Custom software development
with timeline and cost defined upfront.
A structured, repeatable process: analysis, a clickable prototype before any code is written, development with AI in the pipeline, documentation included and human review on every release.
// WHAT IS PUT IN WRITING
What we put in writing, and what usually isn't
This is not a criticism of people who do good work: plenty of development firms deliver excellent projects. The difference is that every line in the right-hand column is a commitment written into the contract, so you can check it before you sign.
Requirements analysis
Usually not guaranteed
Timeline not agreed up front
With us, in the contract
Timeline and cost set in the quote
Prototype before code
Usually not guaranteed
Not always included
With us, in the contract
Always, and clickable before any code
Documentation
Usually not guaranteed
Often quoted separately
With us, in the contract
Included in the price
Change requests
Usually not guaranteed
Priced case by case
With us, in the contract
Defined process, price agreed in advance
Delivery guarantee
Usually not guaranteed
A verbal commitment
With us, in the contract
Points signed in the contract
Automated tests
Usually not guaranteed
Not always included
With us, in the contract
From day one, and maintained after release
| Aspect | Usually not guaranteed | With us, in the contract |
|---|---|---|
| Requirements analysis | Timeline not agreed up front | Timeline and cost set in the quote |
| Prototype before code | Not always included | Always, and clickable before any code |
| Documentation | Often quoted separately | Included in the price |
| Change requests | Priced case by case | Defined process, price agreed in advance |
| Delivery guarantee | A verbal commitment | Points signed in the contract |
| Automated tests | Not always included | From day one, and maintained after release |
// THE PROBLEM
Your backlog isn't a resource problem. It's a method problem.
Four symptoms we see in almost every IT department we engage with. They all share the same root cause.
Maintenance eating your capacity
Bugs, patches and urgent requests consume most of your developers' hours. New projects only get the leftovers.
Backlog frozen for months
Weeks to gather requirements, weeks to validate them. By the time a decision is reached, the original need has already shifted.
Endless change requests
The business evolves faster than the project being built. At release, half the original assumptions are obsolete.
Trust between business and IT erodes
Deadlines missed, costs doubled, and only half of what was promised delivered. Next time, you just buy a packaged solution and live with the compromise.
→ All these symptoms share one cause: the absence of a structured process where AI works alongside the people writing the code, from the analysis phase. The factory exists to provide that structure.
// THE METHOD
Five phases. No improvisation.
You know in advance what will happen, on what timeline, at what cost. Each phase produces an artifact you see and approve.
Discovery and requirements
We work with the key people in the process: recorded interviews, existing documentation, real data. AI structures what we gather and flags gaps and contradictions before they become bugs.
Analysis measured in days, not months.
Navigable mockup
We build a clickable prototype of the main screens. You actually try it, tell us what to change, and we exit this phase with a shared, signed scope.
No surprises at go-live.
AI-in-pipeline development
The validated analysis becomes the working spec. AI works with the full context — requirements, rules, integrations — and produces consistent code. A person orchestrates, validates and rewrites where needed.
Less time spent redoing work from scratch.
Documentation generated alongside the code
User manual, technical manual and changelog are produced by the pipeline and stay in sync with the code. They aren't an "extra" tacked on at project end.
Always included, always aligned with reality.
Human review on every release
Every release goes through human code review, functional and end-to-end tests, architectural validation. AI accelerates, the decision stays human.
No release ships without a person having reviewed and tested it.
// THE GUARANTEE
Four commitments. All written in the contract.
Not a slogan: concrete points we expose ourselves to formally, in plain text, before signature.
Timeline defined before we start
There's a timeline in the contract. It's not "flexible" or "to be defined later".
Code only after mockup approval
We don't write a line until you've said yes to the clickable prototype.
Fixed cost, transparent change requests
Quote locked on the validated analysis. Modification requests are handled with a defined process, not surprise invoices.
Documentation delivered with the software
User manual, technical manual, release notes. In the package, no add-ons.
// LEGACY
A system from ten or twenty years ago that nobody wants to touch?
It's the gray zone of almost every Italian IT department: written by people no longer there, half-documented, and now untouchable. We approach it with a dedicated method.
Before touching anything we work out what the system actually does, and who uses it
What we work out stays with you as documentation, even if the project stopped there
One part is replaced at a time, while the old system keeps running
The risks we see most often
Rising maintenance costs
Every change takes far longer than planned, because you first have to work out what it might break. You spend money to avoid damage, not to make things better.
Single-person dependency
When the only person who really understands the system leaves, every change becomes a minefield.
Innovation blocked
You can't integrate new tools on a base nobody fully understands.
Security at risk
Outdated libraries, unpatchable dependencies, security audits impossible to close.
How we tackle it
We use AI to analyze the existing codebase even without documentation, reconstruct hidden business rules, generate the missing documentation, and design an incremental refactoring plan — module by module, without stopping production.
→Parliamone// DOCS & TESTS
What you usually pay extra for. With us, it's in the package.
Automated documentation
Functional documentation
Flows, rules, use cases, exceptions.
Technical manual
Architecture, API, data schema, integrations.
User manual
Operational guide for the people who'll use the system every day.
Changelog and release notes
Clear history of what changes in each release.
Tests from day one
- Unit tests on every component that deserves protection.
- Integration tests on critical end-to-end flows.
- Functional tests derived directly from validated analysis.
- Structured UAT before go-live, with written acceptance criteria.
- Automated tests maintained on every release, not just at launch.
// CHECKLIST
Questions to ask before choosing a software vendor
They apply to us and to any other supplier.
About the process
- 01.How do you concretely gather and validate requirements?
- 02.Do I get a clickable mockup before development starts?
- 03.Is there a defined process for handling change requests?
About code quality
- 01.Which code standards do you use? How do you enforce them?
- 02.Do you have automated tests? What kind? What coverage?
- 03.Do you do code reviews before every release?
About documentation
- 01.Are technical and functional docs included in the price?
- 02.How do you keep them up to date in the months after delivery?
- 03.Would an external developer understand the system starting from docs alone?
About continuity
- 01.If the original developer is unavailable, how do you handle continuity?
- 02.Is the code fully owned by the client across all components?
- 03.Is there a documented onboarding process for new developers?
If the answer you get is "it depends" or "we'll figure it out as we go", that's a signal worth noting.
Want to talk about it?
30 minutes of free conversation. If the problem is worth it, we'll propose how to tackle it. If we're not the right fit, we'll tell you immediately.