Skip to main content

Web Applications and SaaS Development

A web app or SaaS product built around your real process — permissions, integrations and code you own.

The problem we solve

What we usually find is not an absence of systems but a surplus of them. One tool for sales, a spreadsheet for pricing, a chat thread for approvals, and a different version of the truth in every department. Time goes into reconciling versions rather than doing the work, and nobody can say with confidence who approved what, or when. When companies try to solve this with another packaged system, they discover the customisation they need exceeds what the platform allows, or costs more than building it properly. So we begin with the process itself: simplify it first, then build only the part that earns its place in code.

Expected outcomes

  • One authoritative record instead of competing copies moving between departments.
  • Clear approval steps with a durable trail of who decided what, and when.
  • Less of the day spent moving data by hand between disconnected tools.
  • Precise permissions governing who can see and change each thing.
  • A technical base that absorbs new modules without a rebuild.
  • For products sold by subscription: new customers onboarded and billed without manual intervention.

Who this is for

  • Companies running a core process on spreadsheets that have long outgrown them.
  • Operations teams working across systems that do not talk to each other.
  • Founders building a subscription software product who need a full engineering team.
  • Organisations stuck with a legacy internal system that is hard to extend or staff.
  • Businesses that need a customer or supplier portal on top of existing internal systems.

Use cases

  • An internal operations console bringing jobs, resources and status into one view.
  • A customer portal for tracking orders, documents and invoices without emailing anyone.
  • A multi-tenant SaaS product with per-customer data isolation and subscription plans.
  • A workflow and approvals system replacing email chains and attachments.
  • A quoting or pricing tool encoding rules that only your business uses.
  • Phased replacement of a legacy internal system without pausing daily operations.

Deliverables

  • A running application in production, with a matching staging environment.
  • The complete source code in a repository owned by your company.
  • API documentation, the data model, and a permissions matrix.
  • Automated deployment pipelines with the ability to roll a release back.
  • Monitoring and alerting for failures and for performance under load.
  • A concise user guide and a recorded training session.

Project phases

Discovery and process mapping

Sessions with actual users to document the process as it runs today, including friction points and exceptions.

Scope and architecture

The first release defined, plus data model, roles and permissions, and hosting and integration decisions.

Design and prototype

Core working screens as a clickable prototype, tested with users before code is written.

Development in short cycles

Modules built in the agreed order, each cycle closing with a review on staging.

Migration and release

Data migration, performance and permission testing, then a monitored release with a rollback plan.

Operation and iteration

Usage and incident monitoring, followed by the deferred modules in business priority order.

Estimated timeline
10 to 20 weeks
An estimate that depends on scope and how quickly reviews come back — not a contractual commitment in itself.
Pricing
After scoping
Price follows screen count, the complexity of your business rules, the number of integrations and expected usage. We prefer a scoped first release followed by continuous development, and send a proposal after the scoping workshop.

Scope and working details

What is in and out of scope, how we work, and what we need from you.

What is included

  • A working session to map the current process and identify what genuinely deserves software.
  • Definition of the first release, and what is deliberately deferred beyond it.
  • Experience design and the core working screens.
  • Data modelling, roles and permission design agreed before development starts.
  • Front-end and back-end development with documented APIs.
  • Secure authentication and session handling, with an audit trail on sensitive actions.
  • Integrations with the systems you already run: accounting, HR, messaging, payments.
  • Automated tests on critical paths and a staging environment that mirrors production.
  • Cloud deployment with backups, a rehearsed restore, monitoring and alerting.
  • Team training and handover of technical and operational documentation.

What is not included

  • Creating a brand identity from scratch — we work with the one you have.
  • Manual entry of historical data — we migrate what can be migrated and agree the rest with you.
  • Cloud and third-party subscription costs, which stay in your company name.
  • Issuing compliance certificates or formal audit opinions — we apply and document engineering practice; certification belongs to an independent body.
  • Native mobile applications, which are a separate engagement.

How we work

We do not build the request literally before understanding why it was made. We sit with the people who do the work daily, not only those who describe it, and come away with a list ordered by impact rather than by ease of build. The first release covers the most important path and reaches real users early, because one comment from someone doing the job beats weeks of assumption. From there we work in short cycles, each ending in something usable on staging, so you watch progress instead of reading about it.

What we need from you

  • A product owner on your side with regular weekly time and authority over priorities.
  • Access to the people who run the process today, not just its documented description.
  • Documentation of current rules: pricing, approvals, recurring exceptions.
  • Realistic data, or an anonymised sample of it, for testing.
  • Early decisions on hosting and on access to existing systems.

Methodology and technology

React on the front end, with Next.js where server rendering or indexability earns its keep. Laravel or Node.js on the back end depending on the nature of the system and what your future team can realistically maintain, with PostgreSQL for data. Permissions are enforced at the data layer rather than in the interface alone, so a change to a screen cannot open an access hole. Encryption in transit and at rest, least privilege for every service, and an audit trail on sensitive operations. Containerised deployment with automated integration and delivery pipelines, plus monitoring, alerting and centralised logs. Deployment into Saudi cloud regions is available where your policy requires data to stay in country.

How this connects to the rest of our work

A service rarely works alone. These come before it or alongside it, and these are the solutions it forms part of.

Services that work with it

Part of these solutions

Frequently asked questions

Who owns the code and the data?

You do. The repository is in your company name from day one, as are the hosting and service accounts, and the data is yours throughout. We avoid closed components that would stop you moving the system to another team. If you decide to continue in-house, we hand over documentation and run a knowledge-transfer session.

What happens when requirements change mid-build?

They will change — that is normal for any system built around a real process. Short cycles and an open priority list exist precisely for that. Changes within the agreed scope are simply resequenced. Anything that genuinely expands scope is estimated separately, and you decide whether it is worth doing now or later.

How do you handle data protection?

Through engineering practice we apply and document: encryption in transit and at rest, permissions enforced at the data layer, least privilege for every service, an audit trail on sensitive actions, and backups whose restore is tested rather than assumed. Formal certification is the role of an independent auditor; our job is to prepare the system and the evidence for that review.

Could our own team take over development later?

Yes, and we build for that. We use widely adopted technologies you can hire against, document the APIs and data model, and keep deployment automated so nothing depends on one person knowing the trick. Many clients start with our team and grow an internal one alongside it, and we support that transition.

How long until we have something usable?

The range on this page refers to a first release running in production for one core workflow. A system spanning several departments takes longer, which is why we split it into successive releases. The biggest factor in the schedule is usually not development speed but how quickly decisions are made on your side and how available your data and existing systems are.

What happens after launch?

Every project includes a follow-up window where we handle feedback and tune performance under real usage. After that you can run it in-house, or continue with us on a monthly arrangement covering monitoring, security updates and the deferred modules.

Have an idea, or a system that needs work?

Start with a short session to understand where you stand and what the next step should be. If the scope is clear, a written proposal follows.