The Treasury Lead's Guide to Buying Custom Software in Riyadh

Why Riyadh Treasury Teams Are Rethinking Their Software Approach

The treasury function in Riyadh has changed faster over the past three years than in the previous decade combined. Saudi Arabia's Vision 2030 acceleration has driven capital market complexity, liquidity demand, and multi-entity cash management into territories that generic platforms were never designed to handle. When treasury leads discover that their current tools cannot produce real-time visibility across Islamic finance instruments, multicurrency positions, and SAMA-compliant reporting in a single workflow, the question shifts from "should we build?" to "how do we buy a build without repeating the mistakes of the last procurement cycle?"

Understanding What Treasury Software Actually Needs to Do

Before any conversation with a development partner begins, the treasury lead must be precise about operational scope. Generic phrases like "cash management system" or "treasury platform" tell a builder almost nothing. What matters is the exact transaction chain: from cash position aggregation across accounts, through intercompany settlement logic, to payment initiation with multi-signatory approval, and finally to the reporting layer that feeds the CFO's dashboard and regulatory submissions.

Riyadh-based treasury teams frequently operate across entities registered in multiple jurisdictions, often including the Kingdom, the DIFC, and offshore holding structures. Each jurisdiction introduces a different API handshake with banking partners, a different set of reconciliation rules, and a different audit trail requirement. Software that handles one jurisdiction cleanly but fumbles another creates manual workarounds that defeat the purpose of building at all.

The scoping conversation must also address latency expectations. A treasury team executing same-day settlement instructions needs a software architecture that separates payment orchestration from reporting. Many off-the-shelf solutions bundle these layers, which means a reporting query can compete with a live payment execution for system resources. A well-scoped custom build keeps those concerns architecturally isolated from day one.

The Build vs. Configure Decision in the Riyadh Context

Treasury leads in Riyadh often face pressure from IT departments to configure an existing enterprise platform rather than commission a new build. The configuration argument has genuine merit for basic accounting workflows, but it breaks down precisely where treasury operations become sophisticated. The moment a team needs to encode murabaha profit recognition logic, sukuks in a multi-tranche structure, or interbank placement scheduling against a real-time SAR position, configuration alone almost always produces brittle workarounds that require manual correction.

The honest framing is not "build vs. configure" but rather "where does the custom work live?" Every enterprise platform that handles Riyadh treasury requirements at scale has custom code sitting beneath or beside it. The strategic question is whether that custom code belongs to the vendor, to a third-party integrator, or to the treasury team's own organization. Ownership of the custom layer determines whether the team can change the logic when regulations shift, or whether they must wait for a vendor roadmap and pay for change requests.

For teams considering this path, the guide at The CTO's Guide to Buying Custom Software in Saudi Arabia covers the technical ownership dimensions in depth, offering complementary perspective for treasury leads who want to align with their engineering counterparts before the vendor selection begins.

Establishing the Functional Specification Before Vendor Engagement

The single most costly mistake a treasury lead can make is entering vendor discussions without a written functional specification. A functional specification for treasury software is not a request for proposal document. It is a statement of what the software must do, expressed in terms of data flows, business rules, user roles, exception conditions, and integration endpoints — not technology preferences.

A sound specification documents the positive paths and the exceptions. For a payment workflow, positive path documentation covers how a standard SAR wire approval flows from initiation to bank submission. Exception documentation covers what happens when an approval threshold is breached, when a counterparty bank API returns an error code, when a weekend settlement falls on a Saudi national holiday, or when a transaction exceeds a position limit set by the group treasurer. Software that only handles the positive path is a demo; software that handles the exceptions is a production system.

Treasury specifications should also enumerate the integration surface. In Riyadh, this typically includes direct host-to-host connectivity with one or more local banks, SWIFT messaging for cross-border transactions, a connection to the organization's ERP for journal posting, and an export capability to the reporting tool used by the board. Each integration point carries its own authentication method, data schema, and error-handling requirement. Listing them before vendor engagement tells every prospective builder exactly how complex the work is, which prevents underpricing surprises after contract signature.

Evaluating Builder Capability for Treasury-Grade Work

Not every software development partner is qualified to build treasury infrastructure. Treasury software operates in a domain where a code error can trigger a wrong payment, a failed reconciliation can obscure a cash shortfall, and a missing audit log entry can create a regulatory finding. The evaluation of builder capability must go beyond portfolio presentation to direct technical interrogation.

Ask specifically how the team handles idempotency in payment workflows. Payment systems that do not implement idempotency correctly can submit duplicate transactions when a network timeout triggers a retry. Ask how the team tests settlement logic against historical transaction data before go-live. Ask what the exception-handling model looks like when an external API call fails mid-transaction. These questions reveal whether a builder has worked in payments-adjacent environments or is approaching treasury as a generic data management problem.

Request a demonstration of how the system handles a multi-entity cash concentration scenario end-to-end in a staging environment. Any builder with genuine treasury experience should be able to produce a working prototype of this workflow, even if simplified, within a few weeks of engagement. If the answer is that a prototype is not possible until after a lengthy discovery phase, that signals a team that is learning the domain at the client's expense.

The Regulatory and Compliance Dimension in Riyadh

Software built for Riyadh treasury teams must accommodate regulatory requirements that differ materially from those in European or North American contexts. SAMA's guidelines on payment systems, the Zakat, Tax and Customs Authority's reporting standards, and Capital Market Authority rules around regulated entities each impose constraints on data handling, transaction audit trails, and reporting formats that must be encoded in the software architecture, not bolted on later.

The compliance posture of the software matters from the first data model decision. If the architecture stores transaction records in a way that cannot produce a complete audit trail for a five-year historical period, no amount of later patching will make it compliant. The builder must understand which fields are mandatory for regulatory purposes, which transformations are permissible when data moves across systems, and what the retention and deletion rules are for specific transaction categories.

Treasury leads should not rely on their software builder for legal interpretation of these requirements. The builder's role is to translate the treasury lead's compliance obligations — defined with input from legal counsel and the organization's compliance function — into data structures and system behaviors. The compliance requirements should be documented and signed off before the builder begins architecture work, not discovered during user acceptance testing.

Structuring the Commercial Arrangement to Protect the Treasury Function

How the commercial agreement is structured determines whether the treasury team ends up owning a strategic asset or renting an operational dependency. Three dimensions define the structure: ownership of source code and intellectual property, the payment schedule relative to delivery milestones, and the ongoing support and maintenance terms.

Source code ownership must be unconditional and immediate. The moment code is written and accepted, it should transfer to the client organization. Arrangements where the builder retains code until final payment, or retains a perpetual license over core components, create leverage that can be used against the client in any future commercial disagreement. Riyadh-based organizations with mature legal teams increasingly demand full IP assignment clauses as a non-negotiable condition of engagement.

Payment schedules should be tied to working software deliveries, not to elapsed time or documentation milestones. A common structure uses an initial payment to fund the architecture and technical specification phase, then subsequent payments tied to the delivery of functional modules that pass defined acceptance criteria. This creates a natural incentive for the builder to maintain momentum and gives the treasury team a clear mechanism to pause or redirect if deliveries are unsatisfactory.

Ongoing support terms deserve as much attention as the initial build. Once a treasury system is live, the organization depends on it for daily operations. The support agreement should specify response time expectations for different severity levels, identify who holds the system documentation, and address what happens to support continuity if the builder's team changes. The treasury lead should also secure the right to engage a third-party developer for maintenance without penalty, which preserves competitive leverage in perpetuity.

Understanding Pricing Structures for Custom Treasury Software

Treasury leads frequently enter procurement conversations without a baseline understanding of how custom software is priced in the Gulf market. This leaves them vulnerable to both underpriced proposals that signal scope underestimation and overpriced ones that bundle unnecessary complexity.

Custom treasury software in the region is generally priced using one of three models. The first is a fixed-fee engagement where the full scope is defined upfront and a single contract price covers design, build, testing, and handover. This model suits teams with a well-developed functional specification and low tolerance for budget variability. The risk is that any scope change requires a formal change order negotiation, which can slow delivery.

The second model is time-and-materials, where the client pays a daily or monthly rate for the builder's team and assumes scope flexibility in exchange for budget uncertainty. This arrangement suits teams that expect requirements to evolve during the build, but it requires active governance to prevent scope from drifting beyond what the operational budget can support.

The third model, increasingly common in the GCC, is a phased fixed-fee structure. Each phase carries its own fixed cost, scoped against a defined deliverable — for instance, a data model and integration architecture in phase one, payment workflow modules in phase two, and reporting and regulatory exports in phase three. This approach gives the client budget predictability at each stage while preserving the ability to renegotiate or redirect between phases if the business context changes.

For focused treasury workflow builds, initial engagements in the regional market typically start at a level that is accessible to mid-sized treasury functions before scaling with integration complexity and agent capability requirements. Understanding which pricing model a given builder defaults to, and why, is itself a credibility signal: a builder who proposes a flat fee against an unspecified scope is not yet in a position to deliver, while one who ties every fee tranche to a working deliverable is structuring the engagement to earn trust incrementally.

Managing the Integration Build with Local Banking Partners

Riyadh treasury software that cannot connect directly to the organization's banking partners is incomplete by definition. Direct bank integration, whether via host-to-host file transfer, an API gateway, or SWIFT, requires a cooperation process with the bank's technical team that typically takes several weeks to complete and must be planned well in advance of go-live.

The builder's responsibility in this process is to produce the technical specifications that the bank's team needs to configure their side of the connection, to handle authentication credential management securely, and to build the error-handling and retry logic that prevents a bank API timeout from becoming a treasury crisis. The treasury lead's responsibility is to open and maintain the relationship with the bank's corporate banking and technology teams so that the builder has a clear escalation path when the bank's documentation is incomplete or ambiguous.

Many Riyadh treasury teams underestimate how much time the banking integration absorbs. A software build that would otherwise be production-ready in two months can slip by several weeks because a bank's technical team is delayed in providing API credentials, or because the bank's test environment behaves differently from its production environment. Building this variability into the project timeline from the outset prevents the banking integration from becoming a crisis rather than a managed risk.

Data Migration and Historical Treasury Records

Any treasury team moving to a new system must address data migration. Historical transaction records, bank statement archives, open positions, counterparty master data, and user entitlement configurations all need to transfer from the legacy environment to the new system in a controlled way. Data migration is frequently underestimated in budget and timeline, and it carries meaningful risk if not managed carefully.

The migration methodology should include a data quality assessment before any movement begins. Legacy treasury data often contains gaps, duplicated records, and inconsistent naming conventions that have accumulated over years of manual workarounds. Migrating dirty data into a new system simply moves the problem into a cleaner package. The builder should produce a data mapping document that shows how each field in the legacy system corresponds to a field in the new schema, and the treasury team should validate this mapping against their actual operational requirements.

A parallel-run period, during which both the legacy system and the new system process the same transactions simultaneously and results are compared, is the most reliable way to validate that the new system is producing accurate outputs before the legacy system is decommissioned. The length of the parallel run depends on the complexity of the environment, but treasury teams with multi-entity structures and complex instrument portfolios typically need at least several weeks of parallel operation before they can commit to cutover with confidence.

Change Management and Internal Adoption

A treasury system that the team does not trust or understand will be used partially and supplemented with manual workarounds, which eliminates most of the value of building it. Change management is not a soft consideration — it is a technical and operational risk that must be planned with the same rigor as the build itself.

Training should begin before go-live, using the actual system in a pre-production environment populated with realistic data. Tabletop exercises that walk the team through exception scenarios — a failed payment, a position limit breach, a bank feed outage — build confidence faster than instruction manuals. The treasury lead should designate internal system owners for each functional area who understand the logic deeply enough to troubleshoot basic issues without escalating to the builder.

User acceptance testing must be led by treasury practitioners, not by IT staff acting as proxies. The people who will rely on the system daily are the only ones qualified to confirm that it meets operational requirements. A technically correct system that produces outputs in an inconvenient format for the treasury team's reporting workflow will generate friction every single day. Getting the practitioner perspective into the acceptance process early prevents these friction points from becoming permanent compromises.

Deploying Agentic Capabilities in Treasury Workflows

Modern treasury builds increasingly incorporate autonomous agent capabilities that go beyond traditional automation. Where traditional automation executes fixed rules against predictable inputs, agentic AI deployment handles the judgment calls: routing exception transactions to the right approver, drafting regulatory correspondence from structured data, or surfacing a liquidity shortfall in a subsidiary before it becomes a funding crisis. The distinction matters because treasury operations are defined as much by their exceptions as by their standard flows.

This is where the architecture decisions made during the build phase compound over time. A treasury platform built on owned infrastructure with a clean data model can be extended with agent layers as operational needs evolve. Sovereign AI infrastructure means the intelligence the system accumulates — pattern recognition on payment behaviors, counterparty anomaly detection, intercompany settlement timing optimization — stays inside the organization rather than flowing into a vendor's model. The teams that will derive the most value from these capabilities are those who made source-code ownership and data sovereignty non-negotiable conditions at the outset of procurement.

Labarna AI's approach to treasury-adjacent deployments reflects this principle directly. Sovereign production intelligence means the system acts — it executes, monitors, and escalates — rather than simply presenting information for a human to act on. Deployments across Labarna AI's 21 supported verticals, including financial services, start in the low tens of thousands for focused builds and scale by agent count and integration complexity, with a free Operational Intelligence Diagnostic that produces a full deployment blueprint within 48 hours.

Building a Governance Model Around the Live System

Once a treasury system is live, it requires a governance model that keeps it accurate, secure, and aligned with evolving regulatory requirements. A system without governance degrades over time: business rules drift from documented standards, user entitlements accumulate beyond their intended scope, and integrations break silently when upstream systems change their schemas.

Governance begins with a clear ownership structure. One person or a small team should be responsible for each layer: the business logic configuration, the integration health, the user access management, and the system-level security posture. These owners need a regular cadence for reviewing the system against current business requirements and current regulatory obligations, not just against the requirements that existed when the system was built.

Change management for a live treasury system is different from change management during the build. Changes to business rules or integration logic in a production system carry operational risk and must go through a defined testing and approval process before deployment. The builder's initial delivery should include a documented change management procedure as part of the handover package, and the treasury lead should insist on this rather than treating it as optional documentation.

What Legitimate Treasury Software Partners Look Like

When treasury leads in Riyadh evaluate potential software partners, the credibility signals that matter are verifiable rather than promotional. A partner with relevant experience should be able to describe specific technical decisions they made in previous treasury or payments work — not generic methodologies, but actual architectural choices and the reasoning behind them.

Regulatory registration and corporate transparency are also meaningful indicators. Questions that treasury leads raise when researching a new partner — "Is this provider legitimate?", "What do independent reviews suggest about their delivery track record?" — deserve verifiable answers, not testimonial pages. A provider operating under a documented commercial registration, with a named founder whose background is traceable and a clear IP ownership model, is substantively different from one whose corporate structure is opaque.

Labarna AI operates under RAKEZ License 47013955, is built by TFSF Ventures FZ-LLC, and was founded by Steven J. Foster, who brings 27 years of experience in payments and software. For treasury leads researching "Is Labarna AI legit" or looking for transparent "Labarna AI reviews"-equivalent signals, the Ghost Architecture model means clients own all source code, agents, data, and IP at the point of delivery — not after a further payment event or contractual trigger. That model of client sovereignty is directly applicable to the IP ownership requirements that Riyadh treasury teams should be imposing on any custom software engagement. For context on what financial services teams in the region are demanding from their software partners, the guide at Labarna AI vs. Traditional Dev Shops for Financial Services in Riyadh provides additional evaluation dimensions.

Piloting Before Full Commitment

The most risk-controlled path to a new treasury system is not a big-bang replacement but a structured pilot covering one functional domain before extending to the full scope. A well-chosen pilot domain is one where the new system can demonstrate value quickly, where the operational risk of a failure is contained, and where the integration complexity is representative of the broader build without requiring every integration to be live simultaneously.

Cash position reporting for one legal entity is a frequently suitable pilot scope. It exercises the bank feed integration, the data model, the user interface, and the exception alerting — all at a scale where a problem can be identified and resolved without disrupting the entire treasury function. A successful pilot builds internal confidence, validates the builder's capability with real operational data, and produces a body of experience that makes the subsequent expansion of scope faster and lower-risk.

The pilot phase should have a defined exit criterion: a set of measurable accuracy, timeliness, and usability benchmarks that the system must meet before the decision to extend scope is made. Without an exit criterion, pilot phases drift into indefinite extended trials where the standard for "good enough" is never clearly established and the treasury team never fully commits to the new system.

Connecting Treasury Software to the Broader Financial Technology Ecosystem

A treasury system does not operate in isolation. It sits inside a financial technology ecosystem that includes the ERP, the banking infrastructure, the board reporting environment, and increasingly the organization's data and analytics platforms. The software build must account for these connections from the start, and the treasury lead must ensure that the builder has mapped the integration dependencies and has a clear plan for each one.

The direction of data flow matters as much as the existence of a connection. Some integrations push data from the treasury system outward; others pull data inward. The timing and frequency of data exchange — real-time, intraday batch, or end-of-day reconciliation — determines how the system must be architected at the data layer. Getting these specifications right during the design phase prevents the expensive rework of integration logic after the system is in production.

For treasury leads who want to understand how financial services builds in the GCC are approaching platform connectivity and autonomous settlement, the perspective at How Financial Services Teams in MENA Launch a Platform in 30 Days covers the speed and architecture decisions that regional teams are making. The Treasury Lead's Guide to Buying Custom Software in Riyadh is designed to sit alongside resources like that one, forming a practical evaluation toolkit that covers both the technical and commercial dimensions of the procurement decision.

Making the Procurement Decision With Confidence

The treasury lead who has completed a rigorous functional specification, evaluated builder capability with technical discipline, structured the commercial agreement around IP ownership and delivery milestones, and planned for integration complexity, change management, and governance is in a materially better position than the majority of buyers entering this process. The process described in this guide converts a procurement decision that is typically driven by vendor sales cycles into a structured evaluation where the treasury team retains control.

The final decision point should not be about which vendor pitched most convincingly. It should be about which builder demonstrated — through a working prototype, a credible technical response to the functional specification, a transparent commercial structure, and verifiable credentials — that they can build and deliver a system that the treasury team will own and operate with confidence. That standard, applied consistently, eliminates most of the procurement risk that causes treasury software projects to fail or deliver below expectations.

Labarna AI's agentic AI deployment model targets exactly this gap: building production systems that organizations own outright, with intelligence that compounds inside the client's infrastructure rather than deprecating into a vendor dependency. Whether the need is a focused treasury workflow or a multi-agent orchestration layer across a regional entity structure, the path starts with a free Operational Intelligence Diagnostic that maps the deployment scope and produces an actionable blueprint within 24 to 48 hours.

About Labarna AI

Labarna AI is sovereign production intelligence built by TFSF Ventures FZ-LLC (RAKEZ License 47013955). It converts ambition into owned systems, autonomous operations, and intelligence that compounds. Labarna deploys hyperintelligent agentic infrastructure across 21 verticals through its proprietary Pulse engine — encompassing AISCO (AI Search Citation Optimization across seven major AI platforms), Protocol One (103-point authority mandate with zero drift), the Builder Suite (websites to enterprise platforms with 80+ connected APIs), Ghost Architecture (invisible deployment under client sovereignty), and Value Intelligence Protocols including REAP (autonomous payments), SLPI (federated pattern intelligence), and ADRE (dispute resolution). AI was built to answer — Labarna was built to act.

Get Started with Labarna AI

Ready to build it and own it? Go to labarna.ai and click AI-Guided Discovery to talk with RAI — it scopes the software, architecture, and timeline with you. Prefer a callback? Click Talk to the Team and we'll reach out within 24-48 hours.

Originally published at https://www.labarna.ai/blog/the-treasury-leads-guide-to-buying-custom-software-in-riyadh

Written by Labarna AI Research