Skip to content

Custom software that fits how your team actually works.

Most businesses outgrow their spreadsheets and shared inboxes long before they admit it. We build the platform that replaces them: designed around your actual process, owned by you, maintained by the people who wrote it. We do exactly the same for our own product.

  • Cargonio: our own freight ERP: we sell it and support it
  • One API, 3 apps: web, iOS and Android off a single backend
  • Your repos: source, servers and keys under your accounts
  • Docker + CI/CD: same deploy path from laptop to production

When the off-the-shelf option nearly fits

We sit with the people doing the job, then build the system around how the work really flows, with roles, audit trails and integrations, delivered in phases you can use.

Every packaged product makes an assumption about how you work. When that assumption is close enough, buy it: we will tell you so, and we have. The projects worth building are the ones where the mismatch is quietly costing you hours: the reconciliation someone redoes every Friday, the WhatsApp group that has become a job queue, the three systems that disagree about the same invoice. Custom software is worth it when the process is the business, not when it is merely inconvenient.

We build those systems, and we run one of our own. Cargonio is our product: a multi-tenant freight-forwarding ERP covering air and sea import-export operations, invoicing, PRA and FBR e-IMS tax filing, double-entry accounting, HR, payroll and over a hundred reports. It is not a demo built for a portfolio. It has customers, a release cycle, migrations that have to run on live data and support tickets we answer ourselves. Everything that taught us goes straight into client work.

  • Moving job tracking, approvals and scheduling out of Excel and chat threads
  • Launching your own software product for your industry
  • Connecting to government tax systems and payment gateways
  • Shipping e-learning mobile apps with video delivery
  • Founder-led. You deal directly with the people building it.
  • One team, whole stack. Backend, frontend, mobile and hosting in-house.
  • Tested before release. Two QA engineers on every build.
  • Yours from day one. Code, repos and accounts in your name.

Six deliverables.

01

Internal tools

Job files, approvals, scheduling, stock, commissions: the work your team currently tracks in Excel and chat threads, moved into one system with roles, permissions and an audit trail of who changed what. Most of our builds start here, because this is where the pain is measurable.

02

Multi-tenant SaaS

Cargonio gave us the awkward parts in production: data separation between tenants, per-tenant settings and branding, subscription billing, and shipping a change to everyone at once without breaking the customer who configured things differently. If you are selling software into your own industry, that is the same problem set.

03

Government & payment integrations

PRA and FBR e-IMS fiscal invoicing in Pakistan, MyFatoorah in Kuwait, Stripe for card payments elsewhere. The interesting work is not the happy path: it is retries, reconciliation, idempotency, and deciding what the user sees when a government endpoint is down for the afternoon.

04

Accounting & reporting

Double-entry ledgers that actually balance, PDF invoices and statements generated with dompdf, and reports written after watching someone export to Excel and pivot it by hand. Finance teams are the harshest users you will have; build for them early.

05

Mobile apps

React Native for iOS and Android against the same API as the web app, so a change to a rule does not have to be implemented three times. We ship and maintain both stores for Bright Future's e-learning platform in Kuwait, including video delivery over Bunny CDN.

06

Rebuilds

If you already have something that half works, we read it before proposing to throw it away. The usual answer is to replace it module by module while the old system keeps running, rather than a big-bang rewrite that leaves you with nothing usable for a year.

Four steps, in the open.

  1. Step 01

    Sit with the workflow

    Before we estimate anything, we spend time with the people who do the job today: what they type twice, where the process really breaks, which report the boss actually opens. Most of the requirements that matter are never in the brief.

  2. Step 02

    Scope in phases

    We split the build into phases that each end in something you can put into real use, and quote them one at a time. You see working software early, and you are never committed to a year of unknowns on the strength of one document.

  3. Step 03

    Build in the open

    Weekly builds on a staging environment you can log into and poke at. Our two QA engineers test each release against the workflow we mapped rather than the wording of the ticket, which is how the gaps between the two get found.

  4. Step 04

    Launch, then keep going

    We migrate the real data, run old and new side by side where the risk warrants it, and stay on afterwards. Nearly every platform we have launched is still being changed: that is normal for software built around a business, and we price for it rather than pretending it ends.

Stack we use for this

  • Laravel
  • PHP
  • Node.js
  • NestJS
  • Python
  • Django
  • FastAPI
  • .NET
  • C#
  • Java
  • Spring Boot
  • Go
  • Ruby on Rails
  • React
  • Next.js
  • Vue.js
  • Angular
  • TypeScript
  • PostgreSQL
  • MySQL
  • MongoDB
  • Redis
  • GraphQL
  • REST APIs
  • Docker
  • Kubernetes
  • AWS
  • Azure
  • Google Cloud
  • DigitalOcean

Straight answers.

We quote in phases, each at a fixed price, after a short paid discovery where we sit with the people who do the job today. A single number for a whole platform off a one-page brief is a guess, and you end up paying for the guess in change requests. Worth knowing: a fixed price carries a margin for the unknowns, so if your spec is genuinely settled you may do better asking us for a day rate. Discovery is chargeable whether or not you go ahead.