SOLUTION · OWN YOUR SOFTWARE
Full source code repository. Plain Symfony, plain PostgreSQL, plain Australian hosting. No proprietary lock-in.
In SaaS, you rent functionality. The vendor owns the code, the database, the integrations, and the roadmap. When they change pricing, you pay it. When they discontinue a feature you depend on, you adapt. When you outgrow their model, you migrate. None of the value you built up in that system belongs to you. The configuration you spent two years refining, the workflows your team learned, the integrations you paid to build: all of it lives on someone else’s servers, governed by someone else’s terms.
Custom software ownership is the opposite arrangement. You commission the build. You receive the complete source code in a repository under your name. You hold the database. You control the hosting. The system is a business asset on your balance sheet, not a recurring expense on your P&L. You can show the code to your auditor, your lawyer, or your next development partner without anyone’s permission.
That sounds obvious. In practice, plenty of “custom” software vendors build on proprietary platforms, retain the source code, lock the database, or structure contracts so that walking away is impossible. We do not work that way. Paladine builds on open frameworks (Symfony, PostgreSQL, Linux) and hands over everything at the end of every engagement. The handover is part of the deliverable, not a separate negotiation.
The honest moment most agencies skip: most businesses should not commission custom software. If a SaaS product covers 90% of your needs and the 10% gap is workable, the build cost of custom rarely justifies itself. About one in three custom-software discoveries we run ends with our recommendation to keep the SaaS and accept the gaps. Custom becomes the right answer when the SaaS spend has crossed a threshold, when the gaps have become operational risks, or when the data and logic in the system represent genuine competitive advantage. The answer “you do not need custom software” is just as valid as “you do.”
If you have been quoted custom software and the contract is unclear about ownership, call 0431 000 062. We will talk you through what to look for.
You probably want to own your software outright if any of the following are true.
DIAGNOSTIC
If three or more describe your situation, custom ownership is probably the better economic answer. The question is which systems to build and which to keep renting.
Custom software at Paladine means a complete operational system, built on Symfony (PHP), backed by PostgreSQL, deployed on Australian infrastructure. At the end of the build, you receive a handover pack that contains everything required to run, modify, and migrate the system without us. The handover is a deliverable, not a service.
A complete Git repository, hosted under your organisation’s GitHub or GitLab account. Every commit, every branch, every line of code. Documented at the file level. Readable by any competent Symfony developer. The repository is yours from day one of development, not handed over as a final step. You watch the code being written.
PostgreSQL schema documented in plain language. Migration files in version control. Backup and restore scripts. Data dictionary explaining every table and every relationship. You can export the entire database to standard SQL at any time. Your DBA, your auditor, or your next development partner can understand it without us in the room.
Deployment scripts that take a fresh Linux server to a running production system. Documentation of the production environment. Monitoring and alerting configuration. SSL certificates, domain configuration, environment variables. Everything required to stand up a second copy of the system on different infrastructure if you need to. The “what if Paladine disappeared tomorrow” question has a documented answer.
A document that explains the system architecture, the key design decisions, the integrations, the failure modes, and where the bodies are buried. Written for the developer who inherits the system, not for marketing. Every non-obvious decision has its reasoning recorded. The next developer does not need to guess why a specific pattern was used; they read the doc.
A walkthrough with your internal team or your next development partner. Optional, included if you want it. Most clients take it; some have their own teams who prefer to learn the system by reading the code. Both are fine.
The contract states explicitly that all intellectual property in the custom code we write for you transfers to you on final payment. No ambiguity about who owns what. No “licensed back to client” clauses that look like ownership but are not. If a future development partner reads our contract, they will understand immediately that the IP is yours.
Custom software builds run in three named phases. Each phase is fixed scope and fixed price. You can pause between any two phases without losing the work.
DISCOVERY
2 to 4 weeks. Map current state, document business model, identify integration points, define the data model, and produce a written scope and fixed quote. You can take the discovery document to your board.
BUILD
8 to 20 weeks. Stand up the architecture, build the modules, integrate the external systems, write the tests. Weekly demonstration of working software against the agreed scope.
HANDOVER AND CUTOVER
2 to 4 weeks. Production deployment, data migration from existing systems, technical handover documentation, training session. Source code, infrastructure, and documentation fully transferred.
Total timeline is typically 12 to 24 weeks for a focused operational system. Larger ERP or platform builds can run 6 to 12 months.
We do not do agile-as-an-excuse-for-no-scope. The discovery phase produces a written scope and a quote you can take to your board. Inside that scope, we work in weekly iterations and adjust as we learn, but the destination is agreed in writing before we start building. If something changes mid-build, we re-scope and re-quote that change separately; the original scope stays honest.
We structure custom software ownership engagements in one of three ways. All three result in you owning the source code at the end.
Call 0431 000 062 to talk through which fits.
Three custom builds. All in production. Source code owned by the client.
No account managers, no offshore teams, no juniors learning on your project. The two engineers below scope, build, and ship the work. The engineer who runs your discovery is the engineer who writes the code, who runs the handover, and who answers the phone in year three if you call with a question. Custom software is a long relationship; the relationship should be with people, not with an account team.
Nicolas Wendell
MANAGING DIRECTOR
Nicolas has been building custom software since leaving school, bringing a lifelong passion for development to every project. Before founding Paladine Systems, he ran his own video game studio and earned multiple accolades in network engineering. Known as a driving force in the custom software world, Nicolas combines deep technical expertise with visionary leadership – guiding Paladine in delivering innovative, enterprise-grade solutions.
Mark Morcom
SENIOR SYSTEMS ENGINEER
Mark is a young prodigy in software development, bringing 5 years of experience to Paladine. Equally at home on the front end and back end, he crafts clean, scalable solutions that power complex applications. Mark’s sharp problem-solving skills and passion for innovation make him a driving force behind Paladine’s most advanced projects.
The contract states that all intellectual property in the custom code we write for you transfers to you on final payment. The Git repository is hosted under your organisation. You can give access to any developer or company you want, at any time. There is no licence-back clause that looks like ownership but is not; the IP is genuinely and unambiguously yours.
You can. You have the source code, the database, the deployment scripts, and the technical documentation. Any competent Symfony developer or development team can take over. We will hand over to your chosen partner at no additional cost beyond reasonable handover time. Some of our clients run their systems themselves; others have moved to other developers; we are not offended by either path.
We build on Symfony (PHP), PostgreSQL (database), and Linux (hosting). All open source. All widely used. There is a global market of developers who can work on Symfony, which means you are not dependent on us specifically. The stack choice is part of the ownership story; building on a niche framework would lock you to whoever knows it.
No. Low-code platforms create the lock-in we are trying to avoid. The code we write is plain Symfony that any Symfony developer can read. If you have been quoted a OutSystems, Mendix, Bubble, or Salesforce-platform build by someone else, the IP and portability story is very different from ours. That is not a value judgement on those platforms; it is a different commercial trade-off.
Custom software has a higher upfront cost and a lower ongoing cost. SaaS is the inverse. The crossover point depends on the system and the scale, but for mid-market businesses spending more than $30,000 per year on a software category, custom usually pays back inside 3 years and saves money every year after that. The discovery phase produces a written TCO comparison so the decision is made on numbers, not intuition.
Yes. If you have a custom system where the vendor holds the code, we can sometimes negotiate transfer, or rebuild the system on a stack you own. Start with a software rescue audit. About half the cases we see can be solved by negotiating a transfer of the existing code; the other half need a rebuild.
No. We deploy where you want. AWS, Azure, Google Cloud, Sydney data centres, your own infrastructure. The deployment scripts make it portable. Most of our clients deploy to AWS Sydney; some prefer their own data centres for compliance reasons. Both work.
Optional Run With Us retainer from $6,500 per month for 24/7 monitoring, continuous development, and security patching. Or you can take over with your internal team or another partner. The system is built to be supportable by anyone competent on the stack. About 60% of our clients stay on Run With Us long-term; 40% go independent. Neither path is the wrong answer.
GET STARTED
