- Market
- Saudi Arabia
- Written for
- CIO, CTO, COO
- Decision
- Decide what engineering to build in-house and what to outsource
Information security for software delivery

ISO/IEC 27001
ISO/IEC 27001 certified
The two models
What each model really costs and really controls
The day rate is the visible number and the least decisive. What separates the models is where the knowledge ends up, how fast you can change direction, and what happens to the system when people leave.
| Option | True cost, beyond the day rate | Where the knowledge accumulates | Speed to change direction | What happens when people leave | Best for |
|---|---|---|---|---|---|
| In-house team | Salaries are only part of it: recruitment, management, tooling, training and the cost of idle capacity between projects. Fixed cost that is efficient when fully utilised and wasteful when not. | Inside the organisation, and it compounds. The team's understanding of your domain deepens over years and becomes an asset competitors cannot buy. | Fast once the team exists, because priorities shift without a contract change; slow to reach that point, because hiring senior engineers takes months. | Departures hurt most here — knowledge walks out with a person unless it was written down, so retention and documentation are the real risk to manage. | The software that is your competitive advantage, and any domain where deep, accumulating knowledge is the point. |
| Outsourced team | A higher day rate but no recruitment, management, idle time or training cost, and it scales to zero when the work ends. Variable cost that suits uneven or time-boxed demand. | With the supplier unless you require otherwise, which is why ownership and handover terms are the clause that matters — knowledge you do not capture leaves with the contract. | Fast to start, because a capable team is available now; slower to redirect mid-flight, because scope and priorities are set through a contract. | The supplier absorbs turnover, so an individual leaving is their problem to backfill, not yours — provided the work and decisions were documented as they went. | Time-boxed builds, capacity spikes, and the undifferentiated software every company needs but none competes on. |
The line that decides
Core versus context is the cut that matters, not cost
The useful distinction is between the software that is your business and the software that merely supports it. If a system is the reason customers choose you — the pricing engine of an insurer, the routing brain of a logistics firm, the matching logic of a marketplace — it is core, and outsourcing it hands your advantage to a supplier who can sell the same capability to your competitor tomorrow. Core software should be owned by people who stay, because the accumulating knowledge is itself the moat.
Context is everything else: the internal admin tools, the standard integrations, the reporting, the parts that every company in your position also runs and that no customer chooses you for. Owning context in-house ties scarce senior engineers to work that creates no advantage, and it is the natural candidate to buy off the shelf or outsource so your own people are freed for the core. The common mistake is inverting this — outsourcing the differentiating system because a vendor quoted a low rate, and staffing the internal expense-report tool with the best engineers in the building.
One organisation, a split by advantage
A core team on the edge, hired capacity on the plumbing, and a dated transfer for the rest
Illustrative split
A financial services firm has a pricing engine that is genuinely why customers choose it, a long backlog of internal tools and standard integrations, and an ambition to build an in-house data capability it does not yet have the people to start. It cannot hire fast enough for all three at once.
- 01A small, senior in-house team owns the pricing engine and the architectural decisions, because it is the core and the accumulating knowledge is the advantage that must stay in the building.
- 02The internal tools and standard integrations — the context every firm runs and none competes on — go to an outsourced team, freeing the scarce senior engineers from undifferentiated work.
- 03The new data capability is stood up through a build-operate-transfer: an outsourced team builds and runs it while training the in-house people recruited in parallel, with the handover set as a dated deliverable rather than a closing-clause aspiration.
The advantage stays owned by people who stay, the plumbing is delivered without tying up the core team, and the capability being built up ends with the firm rather than the supplier. The split held because it was drawn by what is core, not by who quoted the lowest rate.
Our role
How we work whether the answer is in-house, outsourced or both
- 01
The outsourced option, built to hand back
When we deliver as your outsourced team, we write the code in a repository you own with the documentation and tests that let you bring it in-house later, so choosing us does not quietly become a dependency you cannot leave.
- 02
Standing up your own team
Where you want an in-house capability, we work alongside your engineers rather than instead of them, mentoring as we build so the knowledge accumulates on your side, which is the opposite of an arrangement that keeps you dependent.
- 03
A transfer with a date
In a build-operate-transfer engagement we treat the handover of the running system and the trained team as a dated deliverable we are measured on, not a good intention, because a transfer that never arrives is just outsourcing with a nicer name.
Which of your systems are core and which are context is yours to judge; we deliver either model and design the outsourced one so the knowledge and control end up with you rather than with us.
Common questions
What buyers ask
Is outsourcing actually cheaper once we count everything?+
Sometimes, and not for the reason people assume. The day rate of an outsourced team is usually higher than an in-house salary, so on that number alone it looks more expensive. What tilts the total is everything around the salary — recruitment, management, tooling, training and, above all, the cost of paying a fixed team during the gaps between projects. For steady, long-run work that keeps an in-house team fully occupied, in-house is typically cheaper over time; for uneven, spiky or time-boxed demand, outsourcing wins because it scales to zero when the work stops. The right comparison is not rate against salary but total cost against your actual pattern of demand.
How do we keep control and knowledge if we outsource?+
By making ownership a contract term rather than a hope, and by keeping the architectural decisions on your side. The practical measures are concrete: the code lives in a repository you control from the first commit, decisions are documented as they are made rather than reconstructed at handover, at least one person on your side understands the system well enough to brief a replacement supplier, and the contract states who owns the source and how an exit works. Loss of control does not come from outsourcing as such; it comes from outsourcing the thinking as well as the typing, and from discovering at the end that the only people who understand the system work for someone else.
We want our own team eventually but cannot hire fast enough. What do we do now?+
This is the situation a build-operate-transfer arrangement is designed for, and it is a legitimate middle path rather than a compromise. An outsourced team builds and runs the system now, so you are not blocked by a hiring timeline, while it trains and hands over to the in-house people you recruit in parallel, so the capability ends up yours. The critical detail is that the transfer must be a real, dated deliverable the supplier is accountable for, with named knowledge to be handed over and a point at which your team is genuinely operating the system. Without that, the arrangement quietly becomes permanent outsourcing, which may be fine if chosen deliberately but is a failure if it was meant to be temporary.
In this cluster
A short review that draws the line through your systems between the software that is your advantage and the software that is plumbing, and recommends what to keep, build or hand over.
Draw the line for your systems