01
Small on purpose
You work directly with the people building your system — no account layers, no offshore hand-off, no junior team learning on your budget. A small studio that stays close to the work.
Bespoke operational software
Software that fits the way you actually work.
Petit Solutions designs, builds and maintains bespoke operational systems — applications, AI agents, monitoring and reporting — for small and mid-sized businesses who would rather own their tools than rent someone else's.
Source code you own outright
Fixed scope after discovery
No lock-in, no per-seat pricing
A system, in outline
Modular · Auditable ·
Owned by the client
Owned by the client
Core system
AI agents
Sources
Reports
Approach
Discovery-led
Two weeks understanding
before a line of code.
before a line of code.
Delivery
Working software in weeks
Not months of slides.
Our position
We're not a platform. We're the people who build yours.
Most software asks your business to bend around it. We work the other way round: we learn how your team actually operates, then engineer a system that fits — documented, maintainable and handed over properly.
02
Engineered properly
Tested code, sensible architecture, real backups, monitoring from day one and documentation a future developer can actually read. Substantial systems, not prototypes dressed up as products.
03
Yours outright
You own the code, the data, the infrastructure accounts and the intellectual property. If we ever part ways, your system keeps running — and someone else can pick it up without drama.
What we build
Four kinds of system. One standard of build.
Every engagement is different, but the underlying discipline is the same: understand the operation, remove the friction, and leave behind something your team can rely on for years.
01 / APPS
Operational applications
Internal tools shaped around your process rather than a generic template. The awkward steps — the spreadsheets, the double entry, the "just email Dave" — get designed out, not automated around.
02 / AGENTS
AI agents that do the work
Practical automation wired into your real systems and data — with clear boundaries, audit trails and human checkpoints where judgement matters. Useful on a Tuesday afternoon, not just in a demo.
03 / WATCH
Monitoring & alerting
Quiet systems that keep an eye on operations, integrations and data quality — catching the exception before it becomes a problem, and telling the right person in the language they already use.
04 / REPORT
Reporting & insight
Numbers your team trusts, refreshed automatically, in the shape the boardroom and the shop floor actually need. One agreed version of the truth instead of six competing spreadsheets.
How we work
A considered process, not a sprint theatre.
Five stages, typically eight to sixteen weeks for a first working release. You see working software early and often — and you always know what happens next.
01
We sit with the work
Before a line of code, we spend time with the people doing the job — on the floor, in the office, on the calls. We map the real process, including the parts nobody wrote down.
02
We draw the system
Data model, integrations, permissions, failure modes, hosting. Decisions get made on paper where they're cheap to change — and written down so they're never a mystery later.
03
We build in thin slices
Working software every week or two, tested against real scenarios and shown to the people who'll use it. Feedback shapes the next slice, not a change-request invoice.
04
We hand over properly
Source code, infrastructure accounts, documentation, runbooks and training — transferred to you. Your name is on the accounts from day one, not ours.
05
We stay close, on your terms
Most clients keep us on for improvements and support — as a straightforward monthly arrangement you can end whenever you like, not a subscription you can't escape.
Owned vs. rented
The difference shows up in year three.
Off-the-shelf tools are brilliant — until your process doesn't fit them, the pricing changes, or the feature you depend on gets retired. Here's what changes when the system is genuinely yours.
Typical SaaS
Rented software
Fast to start. Expensive to live with.
- Your process bends to fit the product's roadmap
- Per-seat pricing that scales faster than your margins
- Data exports that are technically possible, practically painful
- Support queues, release notes you didn't ask for
- Five tools that don't quite talk to each other
Petit Solutions
Built & owned
More considered up front. Compounding after that.
- The system matches how your team already works
- Predictable cost — no per-seat surprises as you grow
- Your data, in your accounts, exportable any time
- A direct line to the people who built it
- One coherent system instead of a stack of patches
How the studio thinks
A few principles we won't compromise on.
These aren't values on a wall — they shape how we scope, how we build, and what we're willing to leave out.
01 / DISCOVERY FIRST
Understand the operation before designing the system.
We learn how the work is actually done — not how the org chart says it is — before we agree scope. Every engagement opens with a paid discovery. If the answer is "you don't need us", we say so.
02 / FIXED & TRANSPARENT
Fixed scope, fixed price, plain reporting.
Builds are quoted on scope, not billed on hours. Retainers come with a one-page monthly report you can read in five minutes: what the system did, what we tuned, what's coming. No mystery invoices.
03 / OWNED, NEVER LOCKED
You own the code, the accounts, the IP.
Source code, infrastructure accounts, data and documentation are yours from day one — not held in a proprietary platform. If we ever part ways, your system keeps running and any competent developer can pick it up.
Working principle
"If it can't be explained on a whiteboard in ten minutes, it probably isn't the right system yet."
Straight answers
Questions we're asked before every engagement.
If yours isn't here, ask it directly — we'd rather have an honest conversation than a polished sales call.
Ask us somethingMost first projects land between £20,000 and £70,000 depending on scope and integrations, with a fixed price agreed after discovery. Ongoing improvement and support is usually a simple monthly arrangement — not a per-seat licence, and cancellable with 30 days' notice.
Yes — completely. Source code, documentation, infrastructure accounts and intellectual property are transferred to you. There's no proprietary runtime, no licence key, and nothing that stops another team picking the system up in future.
Usually, yes. Most of our work sits alongside existing systems — accounting, ERP, CRM, warehouse tools — connecting them properly and filling the gaps rather than replacing everything at once. Replacement only makes sense when it genuinely pays for itself.
We use AI where it removes real work: drafting, classifying, extracting, reconciling, summarising. Every agent has defined boundaries, logging and a human checkpoint where judgement matters. If a simple script does the job more reliably, we'll build the script.
Monitoring, backups and security updates are in place from day one. Most clients keep us on for ongoing improvements and support, but you're never obliged to — the documentation and handover are designed so your system doesn't depend on us being in the room.
Heavily at the start — discovery usually means a few days of your team's time — then lightly during build, with a short review session every week or two. That rhythm is what keeps the system grounded in how you actually work.
Start a conversation
Tell us what isn't working properly yet.
Send a note about the process, the spreadsheet, or the system your team has quietly outgrown. We'll reply within two working days with an honest view — including if we're not the right fit.
Free 45-minute working session
No obligation, no sales script
Fixed scope & pricing after discovery
Request a working session
A few details help us make the first conversation useful.
Thank you — your email client should have opened.
If it didn't, write to us directly at info@petitsolutions.com. We'll come back to you within two working days, usually with a couple of questions before anything else.