Skip to content
XSIS
Talk to an engineer

Software engineering

Custom software development

Software built around how your business actually runs

Business applications, platforms and back-end services, designed, built, tested and supported by one accountable team.

Overview

Off-the-shelf software fits most of a business. Custom software is for the part that makes yours different: a pricing engine, an operations platform, a portal your clients sign in to, or the services that hold your other systems together.

We design, build and test that software with one accountable team. Product, architecture, engineering and QA work from the same backlog, and you see working software early and often, not a document at the end.

We build for the long run. Code is reviewed, tested and documented, deployments are automated, and the system is handed over in a state your own engineers, or ours, can keep changing safely.

What we deliver

  1. Discovery summary

    The problem, the users, the constraints and the first release, agreed in writing before the build starts.

  2. Architecture and decision records

    A system design with the reason behind each major choice, so later changes start from what was decided and why.

  3. Prioritised backlog

    Features broken into small, testable items with acceptance criteria, ordered by value and risk.

  4. Working application

    Front end, back end and APIs built in short iterations and demonstrated to you at the end of each one.

  5. Documented APIs

    An OpenAPI description for every service interface, so other teams and systems can integrate without guesswork.

  6. Automated test suite

    Unit, integration and end-to-end tests that run on every change and stop a release that breaks them.

  7. Delivery pipeline

    Build, test and deployment automated from the repository to each environment, with infrastructure defined as code.

  8. Handover pack

    Source code, runbooks, architecture notes and access, transferred so your team can run and extend the system.

How we work

  1. 01

    Discover

    We meet the people who will use and run the software, map the current process and agree the first release.

  2. 02

    Design

    We shape the architecture, the data model and the key screens, and test risky assumptions with prototypes.

  3. 03

    Build in iterations

    We deliver working increments, demonstrate them to you and adjust the backlog with what we learn.

  4. 04

    Test continuously

    Automated tests run on every change, and QA checks each increment against its acceptance criteria.

  5. 05

    Release

    We deploy through the pipeline with a rollback plan, and watch the system closely after go-live.

  6. 06

    Support and evolve

    We fix, improve and extend the system under a support agreement, or hand it over to your team.

Technologies

Languages
  • TypeScript
  • Java
  • C#
  • Python
  • Go
  • PHP
Frameworks
  • Node.js
  • NestJS
  • Spring Boot
  • .NET
  • Django
  • React
  • Next.js
Databases
  • PostgreSQL
  • Microsoft SQL Server
  • Redis
  • MySQL
  • MongoDB
DevOps and observability
  • Docker
  • Kubernetes
Integration
  • OpenAPI

Ways to work with us

Questions and answers

What drives the cost of custom software?

Scope is the main driver: how many user roles, workflows and screens, how many systems the software must connect to, and how strict the security, audit and availability needs are. The state of your data and the number of people who must approve decisions matter too. We estimate after discovery, from a prioritised backlog, so you can choose what goes into the first release and what waits.

Link to this question
How long does it take to build custom software?

It depends on the scope of the first release, the integrations it needs and how quickly decisions are made on your side. We prefer a small first release that real users can work with, followed by regular increments, over a long build with a single launch at the end. After discovery we give you a release plan, and we report progress against it at every demonstration.

Link to this question
How do you choose the technology stack?

We start from what your team can run and hire for, what your other systems use, and what the software must do. For most business software that means a mainstream language such as TypeScript, Java, C# or Python, a relational database such as PostgreSQL or SQL Server, and the cloud you already use. We avoid niche tools unless they solve a real problem, and we record each choice and its reasons.

Link to this question
Can our own engineers work alongside your team?

Yes. Many clients want their engineers in the same repository from the start, so knowledge stays in-house. We agree the working rules together: code review, branching, the definition of done and who approves releases. Your engineers can join the iterations, pair with ours, or take over parts of the system when they are ready.

Link to this question
How do you make sure the software works?

Every change is reviewed by another engineer and covered by automated tests before it is merged. QA tests each increment against its acceptance criteria, and you see it working at the demonstration. Performance, security and accessibility checks are part of the pipeline, not a phase at the end, so problems surface while they are still cheap to fix.

Link to this question
What if our requirements change during the project?

They usually do, and the process expects it. The backlog is reviewed with you at every iteration, and new or changed items are estimated and prioritised against the rest. On a fixed-scope project, a change is agreed in writing, with its effect on cost and dates, before work on it begins.

Link to this question
What happens after go-live?

You choose. We can support and extend the system under an agreement that sets out response times, monitoring and a budget for changes, or we hand it over to your team with the code, the documentation and a period of overlap. Many clients start with our support and move the work in-house over time.

Link to this question
Who owns the code and the work you produce?

Intellectual property in the work we build for you is yours from the first commit — no assignment step at the end. That covers the custom code, documentation and other deliverables made for you. Anything we bring that existed before, such as internal tools or libraries, stays ours, and you receive a licence to use it in your systems. Open-source components keep their own licences, and we list them for you.

Link to this question
How do you protect our systems, code and data?

Access is granted per person, limited to what each role needs, and removed when that person leaves the project. We work in your repositories and environments if you prefer, use multi-factor authentication, and keep secrets in a vault, never in code. Code is reviewed before it is merged, dependencies are scanned, and production data is not copied into test environments without masking. We agree these controls with your security team at the start.

Link to this question

Tell us what you need to build or connect.

Describe the systems, the timeline and the constraints. The right engineers take it from there.

  • Our team will call you within 24 hours during your preferred time slot
  • Our team is available 24/7