Web applications that hold up in production
Accounts, permissions, payments, real data and real load — the kind of web application a business runs on, not a marketing page with a contact form. Built in React and TypeScript on Node and Postgres, with Arabic and English served from a single build rather than a second site.
A website and a web application are not the same job
Plenty of teams can produce a good-looking page. Far fewer can tell you what happens when two people edit the same record, when the payment provider returns a timeout after charging the card, or when the database needs a schema change on live data with customers mid-session.
Those are the questions that decide whether an application survives its second year. They are also invisible in a design mockup, which is why they get discovered after launch.
We build the second kind. The public site you are reading is itself the example: prerendered for crawlers, served in two languages under one routing system, with a generated sitemap and a soft-404 guard — because a single-page app that answers 200 for a dead URL quietly poisons its own search ranking.
What that means in practice
Every item here is something we built and still run ourselves — not a service line we have only read about.
React, TypeScript, Node, Postgres
A boring, well-understood stack chosen so you can hire for it. Typed end to end, so a renamed field breaks the build rather than a customer’s screen.
Arabic and English in one build
Right-to-left layout, mirrored icons and navigation, Arabic plural forms and locale-prefixed URLs with correct hreflang. We retrofitted all of this into our own product once — which is exactly why it now goes in before the first screen.
Pages engineered to be indexed
Server-rendered HTML for crawlers, per-page canonical and metadata, generated sitemaps and structured data. A JavaScript app that ships one empty shell will not rank, whatever the copy says.
Performance treated as a feature
Core Web Vitals measured and worked on directly — deferred hydration, inlined critical CSS, modern image formats. Speed is a ranking input and a conversion input at the same time.
Authentication and roles
Argon2id password hashing, session handling, two-factor for privileged accounts, and role-based access enforced on the server where it counts — never only in the interface.
Schema changes without downtime
Versioned migrations run against live data with a rollback path. Not a developer connecting to production and hoping.
Tests that block a bad deploy
Unit, integration against a real database engine, and browser end-to-end tests wired into the build so a regression fails before it ships, not after.
Accessible and responsive
Keyboard navigation, screen-reader labelling and layouts that hold from a small phone to a wide desktop — checked on devices, not assumed from a breakpoint.
How a web build runs
The same sequence on every engagement, whatever the stack.
1. Model the domain
Before any screens: what the entities are, who may see what, and which rules the server must enforce. Most expensive rewrites trace back to skipping this.
2. Ship it thin, then deepen
The narrowest version that a real user can complete a real task in, deployed early — then widened. It surfaces the wrong assumptions while they are still cheap.
3. Make it operable
Monitoring, health checks, backups and a rollback path before launch, not after the first incident teaches you they were missing.
Straight answers
The questions that actually come up on a first call.
Usually yes, and we will tell you honestly if a rewrite would cost less than the rescue. We start with a read-only audit — dependencies, migrations, deployment, tests, security — and give you the findings as a document you keep either way.
We design and build the interface. If you already have a designer or a brand system we work to it; if you do not, we produce a clean, consistent interface ourselves rather than sending you away to find one first.
Yes — and that is a much bigger claim than it sounds. It means mirrored layout and icons, all six Arabic plural forms rather than a singular and a plural, locale-correct date and number formatting, per-language URLs with reciprocal hreflang, and Arabic content that reads as though it was written rather than translated. We built all of that for our own product first.
You do, from the first commit, in your own repository. Infrastructure runs in your accounts. There is no arrangement where leaving us costs you the product.
Have a web application in mind?
Send us the problem and we will send back a written scope: what to build first, what to leave for later, and what it would take.
Every project starts with a scoping conversation and a written estimate before any code is written. No retainer required to talk.