01 / Perimeter

Fano, Italy — Central European Time

Custom internal software and system integration for SMEs

I am Mattia Radici, a solution architect based in Italy. I build the software your company needs and cannot buy, and I connect the systems you already run — ERP, CRM, warehouse, e-commerce, customer portal — so your data stops being retyped by someone.

Systems I connect

  • SAP Business One
  • Dynamics 365 Business Central
  • NetSuite
  • Odoo
  • Sage
  • Xero and QuickBooks
  • Shopify
  • WooCommerce
  • HubSpot, Salesforce, Pipedrive
  • Custom CRMs and portals

These are the systems I work on most often, not a closed list. If yours exposes an API, a database or even a scheduled export, it can be integrated. I also work on Italian ERPs — TeamSystem, Zucchetti, Danea, Arca — which is worth knowing if you have an Italian subsidiary, supplier or distributor in the chain.

What I take on
Custom internal software, and the three specialisations that come up most often: ERP–CRM integration, B2B ordering portals, automated data handling.
Who you deal with
One person. Analysis, architecture and code review are mine and I do not hand them on.
Where I work from
Italy, on Central European Time: a working day that overlaps with the whole of Europe, the UK and the first half of the US day. Remote by default, on site where the analysis needs it.
Contracts and data
An EU supplier, invoicing in euros, GDPR by default and hosting in an EU region when you ask for it. English is the working language: documents, code and calls.
What I don't do
Reselling licences, IT support and helpdesk, or projects that start without an analysis.

02 / Diagnosis

The cost of work nobody decided to buy

The most expensive work in your company is the work nobody decided to do

No job description has ever said «retype the orders from the portal into the ERP». Somebody does it anyway, every day, and you pay for that time.

The data already exists. It just doesn't move.

The order is in the portal, the customer is in the CRM, the invoice is in the ERP. The same fact three times, three archives that never speak, and a person in the middle acting as the bridge with copy and paste.

Every manual step is an error waiting its turn

One wrong digit in a product code becomes a wrong shipment, a credit note and an apologetic phone call. The cost is not the minute of data entry: it is what happens when that minute goes wrong.

Decisions are always a day late

If stock is reconciled in the evening and sales the next morning, whoever decides what to reorder is looking at an old photograph. That is not a software problem: it is data travelling too slowly.

Replacing everything is not the answer

Changing the ERP because it doesn't integrate means throwing away years of history, retraining people and postponing the problem by eighteen months. Almost always the system is fine: what's missing is the connection.

How an order travels today

The same order, written down three times. None of the three archives knows about the other two, so none of them can notice the digit that fell out along the way.

Before and after, on the same processes

These are not results measured on clients: they are the process changes an integration produces, described for what they are.

A comparison between the manual process as it runs today and the same process after the systems are integrated.
ProcessBeforeAfter
Order from a resellerArrives by email or WhatsApp, someone interprets it and rewrites it in the ERP.The customer enters it in the B2B portal on their own price list, and it arrives already validated.
Customer recordCreated twice, in the CRM and in the ERP, with details that drift apart over time.Created once and kept aligned both ways, with a written rule on which system wins.
Payment statusSales phones finance to find out whether the customer is in good standing.It is on the opportunity, updated by the ERP without anyone copying it.
Stock levelsA spreadsheet exported last night, already out of date when it is needed.Read from the ERP at the moment somebody asks for it.
Supplier data fileA CSV or XML opened by hand, corrected by eye, imported and hoped for.Normalised and loaded automatically, with rejected rows flagged to the person who can fix them.
A broken data flowYou find out three days later, from a customer who calls in a temper.The system notices, writes it in a log and tells a person.

03 / What I build

One pillar, three specialisations

I build the software your company is missing

The work almost always starts with the same sentence: «we need something that doesn't exist». That is custom software, and inside it there are three specialisations that recur often enough to deserve a page of their own.

Primary offer

Custom software

If your process is unusual, the software should bend to it. Not the other way round.

Some companies lose hours every week bending the way they work to a product they bought. Others keep the most important part of the business running on a spreadsheet only one person can open. The cost is the same in both cases: time nobody decided to spend, and a risk concentrated in a single point. When no product on the market covers your process, the way out is to build the software around the process you already have — and to build it so that it stays yours. In technical terms that means a web application with its own database, its own users and its own permissions, on infrastructure held in your name.

When this is the right work

  • You have seen demos from three vendors and none of them covers the part that actually matters
  • The process that sets you apart from competitors is the one no product handles
  • The work runs on spreadsheets and shared files, and when a formula breaks it is the customer who finds out
  • You have a product that fits eighty per cent, and the remaining twenty costs more than all the rest

What I build, concretely

  • Internal applications for a process that is not on the market: make-to-order production, rental, laboratories, field service
  • Narrow tools that do one thing well, sitting alongside the ERP you keep
  • Portals and private areas for customers, resellers, agents or branches, each with their own data and permissions
  • Document management: quotations, orders, delivery notes, certificates and test reports filed against the job or the customer they belong to, findable by customer and not by folder
  • Replacing systems held together with spreadsheets, shared drives and macros written by someone who has left
  • Replacing an ERP that no longer holds up, when the analysis shows it really is the bottleneck
  • Product configurators and quoting tools that apply your rules without anyone having to remember them

From process to software

Specifications

What I deliver
An application in production with its database, the source code, the technical documentation and the credentials, all held in your name.
How it is built
In milestones you can try: at every delivery there is a part you can use on real data, not a percentage of progress.
What it runs on
Widely used technologies with a deep pool of developers, on cloud infrastructure in your name. No proprietary components of mine.
Indicative time
An estimate, not a contractual commitment: eight to twenty weeks from analysis to the first version in use, depending on how many processes it covers.

The real objections to buying custom software

Won't I end up dependent on you?
It is the right objection and it is defused before signing, not after. The source code, the database, the documentation and the infrastructure credentials are yours from day one: no encrypted components, no usage licence, nothing that stops working if you stop working with me. I use technologies with a wide developer market, so another supplier can pick the project up by reading the documentation.
How does the cost compare with an off-the-shelf product?
Higher at the start, almost always. But the honest comparison is not the starting price: a product has a subscription that grows with users, extra modules are paid for, and customisations on top of the product are the line that gets out of hand. Custom software has its spend concentrated at the start, then hosting and the changes you decide to make. If the analysis shows a product on the market covers you, I say so and I don't sell you a project.
How long before I can use it?
As an estimate and not a commitment: eight to twenty weeks from analysis to the first version in use, depending on how many processes it covers. You don't wait until the end to see something: we start from the part that costs the most manual work today and that goes live first, while the rest is being built. The calendar is one of the first things we discuss on the call, so the dates are set together rather than discovered.
Who maintains it afterwards?
The post-release support period is agreed before we start, with a written scope: it is not an open-ended retainer in disguise. After that there are three routes and you choose: a maintenance agreement with me, your internal IT, or another supplier. For the third to be real you need documentation and ordinary technologies, which is why they are inside the project scope.
Is the code mine?
Yes, source included, and it is not a concession: it is the condition that makes everything else credible. The repository, the infrastructure and the third-party services are in your name, not in mine with a delegation. The handover also includes the architecture document and the technical decisions with the alternatives I rejected and why, which is the part that lets whoever comes next work on it without calling me.
Who writes the code?
Analysis, architecture and code review stay with me: that is where it is decided whether the project holds up. Development I delegate to a small network of people I have worked with for years, and that is deliberate — it keeps costs sane and lets me open more fronts when a project needs it. Every line that reaches production passes through my review, and the person you deal with is still me: there is no account manager in between.

The three specialisations that come up most often

They are particular cases of custom software, not three different services: they recur often enough that it is worth describing them properly, with their own scope and their own data diagram.

01 / Specialisation

ERP and CRM that update each other

Nothing needs replacing here: the systems exist, the connection doesn't.

A salesperson calls back a customer that finance has already put on hold, and neither of them is at fault: the two archives simply never write to each other. Every checking phone call is time paid for twice, and every order booked against an old record is a credit note waiting its turn. I build the layer that keeps customer records, orders and due dates aligned between the ERP and the CRM, in the direction you need: read from one system, reshape the data into the format the other expects, write it, and record what went through.

Data flow

Specifications

Direction
One-way or two-way, decided per entity: which system wins in a conflict is always written down.
Frequency
From near real time on webhooks to a scheduled sync, depending on what the system exposes.
Data access
REST or SOAP APIs, the database, files on SFTP. Where there is no API, we work with the layer that exists.
Indicative time
An estimate, not a contractual commitment: three to eight weeks from analysis to the first flow in production, depending on how many systems and entities are involved.

Concrete examples

  • SAP Business One or Dynamics 365 Business Central connected to the CRM with customer records aligned both ways
  • Xero or QuickBooks updating payment status on sales opportunities without anyone copying it
  • Odoo or Sage kept in step on price lists and customer-specific discounts
  • Shopify and WooCommerce aligned with the ERP on products, stock and orders

02 / Specialisation

B2B portal: resellers order for themselves

Your customers should not have to phone to find out whether an item is in stock.

Every order that arrives by email or WhatsApp costs three times over: someone interprets the request, someone checks whether the goods exist, someone retypes it. And the reseller waiting for confirmation is looking at somebody else's catalogue meanwhile. A portal with each customer's own price list and real stock lets them enter the order themselves, and that order arrives already validated. The commercial rules — discounts, minimum quantities, credit limits — stay where they are in your ERP, read from there rather than copied.

Data flow

Specifications

Who signs in
Resellers, agents, branches. Each account sees its own price list and its own history, not anyone else's.
What is shown
Read from the ERP at the moment of the request, not from a copy exported the night before.
Order out
Enters the ERP already validated on product codes, minimum quantities and that customer's terms.
Indicative time
An estimate, not a contractual commitment: six to twelve weeks, depending on the catalogue and the commercial rules to be reproduced.

Concrete examples

  • Customer-specific price lists taken from the ERP, not from a file someone updates by hand
  • Live stock availability, so nobody sells what isn't there
  • Orders that enter the ERP already validated, with no re-keying
  • Order history and one-click reordering for the reseller, without going through your office

03 / Specialisation

Retyping and data entry taken off the desk

Repetitive work should not be organised better. It should be taken away.

Every supplier sends data in whatever shape they like, and somewhere in the company a person spends their mornings tidying files before they can be loaded. That work appears in no job description, nobody ever decided to buy it, and it is paid for every month. Underneath, the answer is a piece of software that sits in between — middleware — doing three things: it brings different formats back to a single internal shape, it checks the data before loading it, and it rejects bad rows and flags them to a person. It is the least visible part of the work and the part that holds everything up: when something doesn't go through, it should notice and tell you, rather than you finding out three days later from the customer.

Data flow

Specifications

Input formats
CSV, XML, JSON, EDI, spreadsheets, third-party API responses. Everything is normalised towards one internal shape.
What happens to errors
A bad row does not stop the flow: it is rejected, recorded and flagged to a person with the reason.
Auditability
Every run leaves a readable log: what went through, when, how many rows, which rejects.
Indicative time
An estimate, not a contractual commitment: two to six weeks for the first flow, after which each additional feed costs far less than the first.

Concrete examples

  • Supplier CSV, XML and EDI files normalised and loaded with no human step
  • Automatic checks on incoming data, with rejected rows flagged to whoever can correct them
  • Scheduled flows with auditable logs: you always know what went through and when
  • Supplier invoice data entry taken off the desk, with the data arriving already structured

04 / Method

Four phases, three of them mine

How I work

Four phases. Analysis, architecture and code review stay with me, because that is where it is decided whether the project will hold up. Development I delegate to a small network of trusted people: it is the choice that keeps costs sane and timelines flexible when they need to be.

What I look at when I look at a process

A business process has layers, and they are not an abstraction: they are six questions somebody answers every day, usually from memory and always in a hurry. The software that carries the process has the same six layers — and when one of them is missing, that question goes on being answered from memory, only with more screens around it.

  1. 01

    Analysis

    Kept in house

    I look at how people actually work, not how they are supposed to. I trace where data is born, where it is retyped and where it gets lost. What comes out is a list of what costs the most, in real hours.

    What you get
    A map of the data flows and a list of the retyping points, in hours.
    Duration
    1–2 weeks (estimate)
  2. 02

    Architecture

    Kept in house

    I define which systems talk, in which direction and how often. The choices and their limits are documented before any code is written, so you know what you are buying and what happens when something falls over.

    What you get
    An architecture document with diagrams, stated limits and a release plan.
    Duration
    1–3 weeks (estimate)
  3. 03

    Development

    Built in milestones you can verify: at every delivery there is something you can try, not a percentage. If a priority changes, it changes at the next milestone.

    What you get
    Milestones you can try in a test environment, one at a time.
    Duration
    Varies by project
  4. 04

    Code review and release

    Kept in house

    Every line that reaches production passes through my review. Then the release is gradual, with the old process still running until the new flow has proved itself on your data.

    What you get
    The flow in production, documentation and credentials handed over.
    Duration
    1–2 weeks (estimate)

The durations are indicative estimates to help you plan, not contractual commitments: they depend on how many systems are touched and on how quickly access and answers arrive from your side.

The method in detail: what comes out of each phase

What is included and what is not

Included in every project

  • Process analysis and a map of how data and documents actually move
  • An architecture document with the reasoning and the limits of each choice
  • Development, testing and code review done by me
  • A gradual release, with the old process still running as a safety net
  • Technical documentation and handover of code and credentials
  • A post-release support period agreed before we start

Not included, and I say so up front

  • Licences for your own systems and subscriptions to third-party services
  • Hosting and infrastructure, which stay in your name
  • Tax, legal or employment advice on the rules the software applies
  • Extended staff training beyond the handover
  • IT support on networks, workstations and devices
  • Any promise of a financial result: it cannot be guaranteed and I don't make it

05 / Who I work with

Four ways of working together

Who I build for

Four kinds of client, four ways of working together.

SMEs and manufacturers

Companies that already have their systems and their history, and a department spending too many hours acting as a bridge between one piece of software and another. The work here is surgical: touch the minimum, remove the manual work.

Worth it when: you have an ERP you intend to keep, and at least two people passing data to each other by hand.

ERP–CRM integration

Agencies and software houses

I develop the technical part you don't want to keep in house, under your name: integrations, backend, architecture. Your NDA, no contact with your end client, delivery in milestones. I work inside your process, and what I build stays reusable on the next project.

Worth it when: you have won a project with an integration component you don't want to carry internally.

White-label development for agencies

Funded startups

From specification to a product in production, built so your internal team can take it over when it arrives. No technical choices that lock you to me.

Worth it when: you have raised, you need a working product and the team isn't hired yet.

Custom software development

Hospitality

CostoCrudo, the cloud management product I build and run: the most direct evidence that what I design for other people I also maintain on a product I answer for myself.

Worth it when: you are looking for a ready-made front- and back-of-house product, not a bespoke project.

06 / Verifiable

Numbers declared for what they are

What can be checked

This section holds numbers and case studies. Some of the numbers are verified; the rest are conservative estimates rather than measurements, and the ones that are not yet verified say so under the figure, one by one. The case studies declare in the same way whether they are reconstructions. I would rather have a page that explains itself than a page that inflates.

CostoCrudo, a SaaS product in production

I build and run CostoCrudo, a cloud management product for restaurants, with active customers working in it every day. It is not a service I sell from this page: it is the reason I can say I know what it means to keep a system running when it is in somebody else's hands, at seven in the evening, with a full dining room.

07 / Tools

Free, no sign-up

Free tools to download

The documents I actually use in the first phase of a project. You just download them: no form, no email address, no list you end up on. They also work for judging somebody else's quotation. Note: these files are currently written in Italian — an English edition is not published yet.

Integration audit checklist

Forty-six checks to run before connecting two systems, including the three answers that should stop the project.

Printable HTML, in Italian

Download

Shadow work cost calculator

What the time your team spends retyping data between systems costs you per year, in euros. Eight fields, one number, and the threshold below which the work isn't worth doing.

Works offline, in Italian

Download

Request for proposal template

An outline for writing a brief that gets you comparable quotations, plus the seven questions to ask every supplier in identical words. Fill it in the browser and save as PDF.

Fill in and save as PDF, in Italian

Download

08 / Questions

The same ones I get on the phone

The questions people ask before we start

These are the answers to what nearly everyone asks in the first half hour. If yours is missing, write to me.

01

I need software that doesn't exist as a product. Do you build that?

Yes, and it is the work I do most often. The starting point is always the same: I look at how you work now, and work out whether your process is genuinely unusual or whether it resembles something a product already covers. If an off-the-shelf product suits you, I say so and I don't sell you a project. If the part that sets you apart is also the part nobody handles, the software gets built around the process you have: application, archive, users and permissions, with the code and the infrastructure in your name.

02

Custom software or an off-the-shelf product?

It depends on how standard your process is, not on how big the company is. If what you do is done the same way by everyone else, a product costs less and you can buy it tomorrow. If the way you work is the reason customers choose you, a product forces you to bend it, and customisations on top of the product become the line that gets out of hand. The real financial difference is not the initial price: it is a subscription that grows with users on one side, and spend concentrated at the start on the other. That judgement is the first output of the analysis, before any quotation.

03

What does an integration project cost?

I have no price list, and I would be wary of anyone who has one for bespoke work. Four things set the price: how many systems are touched, whether they expose decent APIs or have to be reached another way, how many entities are synchronised and in which direction, and whether users also need an interface. After the analysis you get a fixed figure for the project, not an open hourly rate. If the analysis shows the spend makes no sense against what the manual work costs you today, I tell you and we stop there.

04

How long does it take?

As an indicative estimate, not a commitment: an integration between two systems with usable APIs usually takes three to eight weeks from analysis to the first flow in production; a B2B portal, six to twelve. The variable that moves dates most is not the code: it is how long it takes for access, credentials and answers to arrive from your ERP vendor. The real dates are set at the end of the analysis, when we know what is actually inside the systems.

05

Who writes the code?

Analysis, architecture and code review I do myself and do not delegate: that is where it is decided whether the project holds up. For development, when the volume calls for it, I rely on a small network of people I have worked with for years — but every line that reaches production passes through my review, and the person you deal with is still me. There is no account manager in between.

06

You are in Italy and we are not. How does that work in practice?

I work on Central European Time, which overlaps with the whole of Europe and the UK for a full day and with the east coast of the United States for the afternoon. Work is remote by default: repository, ticket tool and calls on whatever you already use, in English. For the analysis phase I travel where it is worth it, because watching people work is worth more than ten calls — but it is a few days, not a permanent presence, and travel costs are agreed in advance rather than appearing on an invoice.

07

Where does our data live, and who is responsible for it?

The infrastructure is in your name from day one, so the data stays with you: I am a processor working on your systems, not a place where your data is kept. Hosting can be pinned to an EU region — or to another region if your own rules require it — and that decision is written into the architecture document together with what is logged, for how long and who can read it. Where personal data is involved, the flows are designed to carry the minimum needed, which is both a GDPR requirement and the simplest way to keep the system small.

08

What are the contract and the currency?

I am an Italian sole trader invoicing in euros, and the project is a fixed price against a written scope rather than an open hourly rate. I am happy to work under your contract and your NDA; I don't have a template I need you to accept. VAT treatment depends on where your business is registered, and I confirm it before the first invoice rather than after it.

09

What happens if we change ERP in two years?

That is exactly why an integration is built in layers. The logic of your processes lives in the middleware, not inside the ERP: when you change system you rewrite the connector to the new one, not everything else. That point is explicit in the architecture document, so you know in advance what a change would cost and what it would not.

10

Our ERP has no API. Can it still be done?

Almost always yes. APIs are the best route, not the only one: you can work on the database, on scheduled file exports and imports, on feeds dropped on SFTP or into a mailbox. The quality of the integration changes — with files you lose real time — and I tell you that during the analysis, before quoting, not after.

11

What do I end up owning?

The source code, the technical documentation, the credentials to every service and piece of infrastructure, and the architecture document. All in your name. No encrypted components, no usage licence that forces you to stay, no service that stops working if you stop working with me. If one day you hand the system to another supplier, they have everything they need to work on it.

09 / Contact

Half an hour, no automated quotation

Let's have a proper conversation

There is no automated quotation to generate, and I won't send you a brochure. We spend half an hour: you tell me where the work jams, I tell you whether it is a problem I know how to solve and whether the spend makes sense. If the answer is no, I say so straight away.

Or write to me: I answer, usually within one working day.

All the contact details

How the call works

Length
Thirty minutes, video call or phone, in English.
Who is there
Me. No salesperson, no handover afterwards.
What I need
To know which systems you run and where the work jams. Nothing else.
What you get
An honest view on feasibility and order of magnitude. The quotation comes after the analysis, not before.