Custom software development · UAE

Custom software when no product fits how you work.

Webzenia builds where the process is genuinely yours and no product fits. If one does fit, the first thing you get is the shortlist, not a quote.

Tell us what it has to do

The decision before the build

What custom software development is.

Custom software is written for one operation and owned by that operation. The question worth settling first is whether a product already does it.

Built to fitYour custom appOrdersInventoryApprovalsIP: yoursGeneric SaaSunused fieldslocked to vendorShaped to your business. Yours to keep.

Built to your process.

Written around the sequence your team actually runs, including the steps a packaged product treats as exceptions. The fit is the whole reason to build, and it is the first thing lost when scope is cut.

Every account in your name.

The repository, the cloud tenancy and the deployment pipeline are opened in your entity from the first commit, so the software is an asset on your books rather than a dependency on ours.

Your licence shapes the build.

What the entity may sell, to whom, and where its records may sit are architecture decisions. A free zone company and a mainland one need different things from the same screen.

What gets built

Six kinds of custom software brief.

Three of these are this engagement. Three are separate ones, named here so a brief lands in the right scope rather than being priced as this.

Business applicationsyour data modelCustomeridnamecityOrderidcustomertotalInvoiceidordergst1:N1:1your business modelled exactly, not forced into a template

Business applications.

The operational system a trading, brokerage or production business runs on, written to its own sequence of quotes, approvals and records

Output

one place the work lives

OperationsApprovals
SaaS productsmulti-tenantApp coreAcmedataGlobexdataInitechdataone codebase, each customer walled off

SaaS products.

A product other companies subscribe to, with tenants, plans and billing

Output

a separate engagement, because a product is scoped against a market rather than against one operation

Multi-tenantSeparate scope
Enterprise systemslayeredWeb & mobile UIexperienceAPIs & serviceslogicDatabases & queuesdataERP, CRM, banksintegrationsbuilt in layers, so it scales and stays maintainable

Enterprise platforms.

Systems carrying role separation, audit trails and a formal data regime

Output

a separate engagement, because governance is the scope there rather than a feature inside it

GovernanceSeparate scope
API & integrationsREST + webhooksapi.yourco.com/v1GET/ordersPOST/invoicesGET/customersConnectedPayTabsAramexEmaraTaxone clean API your other systems can build on

Integration and API layers.

The layer between the accounting system, the payment rail and the courier, so a record is written once and read everywhere

Output

the retyping stops

APIsTwo-way sync
Legacy modernizationmonolith to servicesLegacymonolithAuthOrdersBillingSearchthe old monolith carved into services, no big-bang rewrite

Legacy replacement.

An unmaintained system read, documented and replaced in stages, keeping the rules that still hold

Output

a codebase a new developer can open

Read firstStaged
Internal toolswired inOps teamadmineditorviewerInternal toolDatabaseAPIsthe small tool that kills the shared spreadsheet

Internal tools.

Admin panels, approval queues and data entry for the team behind the operation

Output

a separate engagement, scoped to the people who open it every day

AdminSeparate scope

Three ways to get software written

Hire, rent, or engage a build.

Three arrangements produce a codebase, and they differ in what you hold afterwards. The difference is contractual, so these are the five terms worth settling first.

Hire the teamEngineers on your own payrollRent a benchHours bought from a delivery shopWebzeniaA build with a named lead and terms
Who is accountableYou are, including the hiring, the review and the quiet quarters.Nobody named. The account manager changes and the engineers rotate.One named person, for the build and for what it does afterwards.
Who holds the IPYour entity, provided the employment contracts actually say so.Whatever the master agreement says, which is rarely read before signing.Your entity, assigned in writing, from the first commit.
Who can run it in a yearThe people who wrote it, for as long as they stay.The shop that wrote it, which is the commercial point of writing it that way.Any competent developer. The repository is documented and the build reproducible.
Which data regimeWhatever your team already knows, on top of shipping the work.A GDPR paragraph, applied whether or not it governs you.The one your entity sits under: the federal PDPL, or the DIFC or ADGM regime if registered there.
What happens on exitThe knowledge leaves with the resignation letter.You hold a repository nobody outside that shop has read.Nothing stops. The accounts, the code and the documentation are already yours.
Which arrangement to choose.

Hire the team when software is what you sell, which is a Hub71 SaaS company on an Abu Dhabi free zone licence. Engage a build when one system has to be built properly once and handed over, which is most operating businesses here. Renting hours pays off only where you already have engineering leadership to direct them, and a bench without it is how the horror stories start. Where the process should be automated rather than rebuilt, the selection tests come first, inside the same AI and automation programme.

The UAE context

What a UAE software brief looks like.

Webzenia has worked with Gulf clients since 2018. Three things separate the briefs worth building from the ones worth buying.

  1. 01of 03
    Most briefs already existThe shortlist comes first

    Most briefs describe a product that already exists.

    A Sharjah HFZA manufacturer arrives with a brief and three quotes; the first deliverable is the shortlist of products that would do it, because a business that buys the right one keeps the money it would have spent proving that. The briefs that survive the shortlist are the ones worth funding.

    Our methodThe product shortlist is written and priced before an architecture is proposed.
  2. 02of 03
    The licence shapes the processWhat the entity may sell

    Your licence shapes the processes no product fits.

    A JAFZA electronics importer on a free zone licence generally cannot sell direct to mainland customers without a distributor, a mainland branch, or a permit under Dubai Executive Council Resolution No. 11 of 2025. That decides who the software may transact with, which is an architecture input rather than a legal footnote.

    Our methodThe licence and its permitted activities are read before the data model is drawn.
  3. 03of 03
    The software has to emitA build requirement

    Your filing obligations decide what it must produce.

    Corporate tax is 9% above AED 375,000 of taxable income, with a 0% rate available to a qualifying free zone person, and VAT registration is mandatory above AED 375,000 of taxable supplies. Which entity issued a record becomes a field, not a convention somebody remembers.

    Our methodTax and invoicing fields are modelled in discovery, before the first screen is drawn.

What the engagement covers

Inside a custom build.

Six stages, in order. The first can end the engagement, because a brief a product already serves should not reach the second.

Discovery · auditSTEP 01PROCESS TODAYIntakeApproveKey inPaybottleneck · 4 hrsWHAT WE AUTOMATEAuto-fetch from emailAuto-key into the ERPAuto-notify when doneWe map the work and find what is worth automating.

Shortlist and discovery.

The process is mapped, and the products that already serve it are listed with what each would cost to adopt. What survives that is the brief.

  • Process map
  • Build or buy
Build · automationSTEP 02FLOWTriggerRuleAI stepActionAI STEP · CONFIGmodelclassify intentfallbackhuman reviewconfidence0.85Built modular, with AI where a step needs judgement.

Architecture and build.

The data model is drawn against the entity and its obligations first, then the software is built in short cycles with a working version at the end of each one.

  • Data model
  • Short cycles
Integrate · your stackSTEP 03Automation coreAll syncedXXeroAccountingnowHHubSpotCRM2mEEmaraTaxTax filing5mWWhatsAppMessaging1mWired into the tools you already run.

Integration.

Wired to the accounting system, the payment rail and the courier the business already runs, so a record is written once and read everywhere it is needed.

  • Accounting
  • Payments
  • Logistics
Monitor · healthSTEP 04AUTOMATION HEALTHInvoice flowrunningReconciliationrunningReport syncretryinguptime · 30d99.9%Report sync retrying — flagged on WhatsApp, no silent failure.Watched, with alerts, so nothing fails in silence.

Testing and release.

Run against real cases and real volumes before anyone depends on it, including the months where the volume is nothing like typical.

  • Real cases
  • Peak volume
Govern · audit + accessSTEP 05AUDIT LOGinvoice-botposted #482110:02Financeapproved batch10:05systemaccess checked10:09ACCESSPDPL-alignedAdminfullApproverapproveBotpost onlyEvery run logged, access controlled, PDPL-aligned.

Access and data rules.

Roles, access and retention designed against the regime the entity actually sits under, settled in discovery rather than after the first request to see an audit trail.

  • Roles
  • Retention
Handover · yoursSTEP 06RUNBOOKRunbook.mdHANDED OVERRepo · transferredAccess · in your nameDocs · completeYour team runs it:PANDocs and access handed over. It is yours to run.

Handover.

Repository, accounts, documentation and a walkthrough with whoever will hold it. The terms were signed before the first commit, so nothing is negotiated at the end.

  • Docs
  • Accounts
  • Walkthrough

Our stack

Built with TypeScript and PostgreSQL.

Five choices, each of which decides something that is expensive to change later. Select one to see what it settles.

TypeScript
Why TypeScript

TypeScript puts a type system over JavaScript, which is what makes a codebase safe to change by someone who did not write it.

How we excel

The whole stack is strict TypeScript, which makes the handover promise testable: a developer who has never opened the repository gets errors at compile time instead of in production.

Safe to changeHiring poolTypes
TypeScriptEnforced
Plain JavaScriptNone
PythonHints
GoEnforced

How the build runs

From shortlist to handover.

Three phases, and the expensive mistake sits in the first. A system architected against a feature list instead of the entity gets rebuilt inside a year.

01Weeks 1 to 3Scoped

Checking no product already does it.

We map the process, list the products that would serve it, and price adoption against a build. Where a product wins we say so and the engagement stops there. Where none does, the architecture is drawn against the entity rather than a feature list: what the licence permits it to sell, which tax treatment each record carries, and the fact that an invoice now has to leave as structured data on the UAE PINT AE format through an accredited service provider rather than as a document the software prints.

  • Productsshortlisted and priced
  • Licenceread before the data model
  • Invoice formatdesigned in, not bolted on
02Weeks 4 to 12Building

Building and wiring it in.

The build runs in short cycles with something usable at the end of each, so scope decisions are argued against a working screen rather than a document nobody reads twice. Integration happens alongside rather than afterwards: the accounting system, the payment rail and the courier are connected while the data model is still inexpensive to change. Roles, access and retention are set in the same phase, against the regime the entity sits under.

  • Cyclesa working version each time
  • Integrationswired during, not after
  • Accessroles set with the build
03Month 4 onwardHeld

Handing over the accounts.

The repository, the cloud tenancy and the deployment pipeline were opened in your entity from the first commit, so handover is a walkthrough rather than a migration. Documentation is written for a developer who has never seen the code, and we ask somebody on your side to read it before the phase is closed. Support and changes continue on a retainer where you want them, and stop without anything breaking where you do not.

  • Repositoryin your organisation from day one
  • Docsread by your side before sign-off
  • Supportoptional, never structural

Agreed before the first commit, and unchanged at handover.

Terms before code
IP assignedPriced per phaseA named lead

Our commitment

Four promises about the terms.

Every buyer asks whether they own the code, and it is usually answered in a sentence. These four are answered in the agreement.

  • The IP and the accounts are yours.

    The repository, the cloud tenancy and the deployment pipeline are opened in your entity from the first commit, and the assignment is written into the agreement rather than referred to by it.

  • Scope and price fixed per phase.

    Each phase carries its own written scope and its own price, agreed before it starts. A change of mind is repriced openly rather than absorbed and recovered somewhere later.

  • The build names its data rules.

    The agreement states which regime the software is designed against, the federal one or the DIFC or ADGM regime where the entity is registered there. A general clause about data security answers a different question.

  • One named lead throughout.

    One senior person owns the build and stays on it through handover. Where that person has to change, you hear it from us before it happens rather than noticing it in a standup.

The code, the accounts and the documentation are yours, stated in the agreement.

Questions

Custom software, answered.

Next step

Tell us what no product does.

Describe the process you are stitching together by hand. We will tell you whether it needs building, or whether something already does it.

Tell us what you need.

+971
Chat on WhatsApp