When you already know what you need — here's how we build it

The post-discovery technical deep-dive: stack choices, architecture documents, integration points, and what production deployment actually includes. Built for teams that have done the brief.

Architecture in 5 business days · mock server by end of week 1 · runbook on launch day.

Quick answer

Who builds custom web solutions for teams that already know what they need?

Ijjad architects and ships custom web solutions for teams across Jordan, Saudi Arabia, Iraq, and the GCC who already have a brief. Ijjad delivers Next.js + Postgres platforms, headless storefronts on Saleor or Medusa, API-first backends, and AI-augmented internal tools — with an architecture document in 5 business days and mock server running by end of week 1.

  • Architecture document signed off before sprint 1; no code until the plan is reviewed.
  • Mock server running by end of week 1 so frontend builds against real contracts.
  • Production runbook delivered on launch day, not three weeks later.
  • PDPL Tier-2 and ZATCA Phase 2 baked into Saudi engagements by default.

Where this page sits in the Ijjad journey

Three Ijjad pages talk about web development, and they're intentionally not the same. web-development-services is the pre-discovery hub — for teams still deciding which agency to call. website-cost-estimator is the scope-tier overview for any project type. This page is the technical layer underneath both: the architecture documents, stack choices, integration points, and runbooks that come after the brief.

Read this if you already know you need a custom platform — B2B portal, headless storefront, AI-augmented internal tool, multi-region rollout — and you want the engineering detail before you scope it. Skip this if you're still evaluating agencies or pre-brief.

Custom platform outcomes

Client names withheld under NDA. Every figure is verifiable through the linked anonymized case study.

Stack & scope tiers

Four delivery shapes for custom platforms

Pick the stack that matches your scale, compliance needs, and integration depth.

Next.js + Vercel

Content-led, conversion-focused, multi-region brands.

After scope review

6-12 weeks

  • Next.js + TypeScript
  • Vercel edge deployment
  • Headless CMS (Sanity / Payload)
  • Multi-region hreflang
  • Image optimisation pipeline
  • SEO foundations
  • Heavy editorial workflows (use Drupal)
Get Started
Most popular

Headless platform

E-commerce with custom storefronts, multi-tenant SaaS.

After scope review

8-14 weeks

  • Saleor / Medusa / Payload
  • Custom storefront (Next.js)
  • GraphQL or REST API layer
  • Stripe + Mada subscription billing
  • Webhook + queue architecture
  • Observability baseline
Get Started

Custom Postgres + Node

B2B portals, internal tools, AI-augmented platforms.

After scope review

10-16 weeks

  • Node.js + Postgres + Redis
  • Role-based access + SSO
  • Background jobs (BullMQ / Inngest)
  • Admin dashboards (Next.js)
  • API contract + OpenAPI docs
  • Audit logs + observability
Get Started

Enterprise / Gov

Ministries, regulated finance/health, multi-product platforms.

After scope review

16-32 weeks

  • In-Kingdom hosting (STC Cloud / Mobily)
  • PDPL Tier-2 + sector compliance
  • Saudi National Design System alignment
  • SSO + RBAC
  • Multi-environment CI/CD
  • 24-month maintenance plan
Get Started

Every tier includes architecture documentation, automated CI/CD, observability, and a 30-day post-launch on-call window. You own the repo and deployment credentials on day one.

How a custom build runs

From architecture document to production

Architecture before code. Mock server before frontend. Runbook before launch.

  1. 1

    Architecture doc

    5 business days

    Stack choices with rationale, data model, API contract, deployment topology, integration points, observability plan, and risk register. Signed off before any code begins.

    Deliverable: Architecture document + risk register.

  2. 2

    Mock server + design system

    1-2 weeks

    Backend: OpenAPI mock server running by end of week 1 so frontend can build against real contracts. Frontend: design tokens, component library, RTL parity.

    Deliverable: Mock server + design system.

  3. 3

    Build

    4-24 weeks

    Two-week sprints. Backend, frontend, and DevOps run in parallel. Weekly Vercel preview builds. Bundle budgets enforced per route. Schema, accessibility, and PDPL/ZATCA controls baked in from sprint 1.

    Deliverable: Weekly previews + sprint demo Loom.

  4. 4

    Hardening + QA

    1-3 weeks

    Load testing, OWASP Top 10 security review, accessibility audit (WCAG 2.2 AA), bilingual QA, and per-country edge-case testing.

    Deliverable: Security report + accessibility report.

  5. 5

    Launch + ops handoff

    1-2 weeks + ongoing

    Production deploy, runbook delivery, on-call rotation setup, and 30-day post-launch window. Optional maintenance retainer stacks on top.

    Deliverable: Live platform + runbook + incident playbook.

Typical end-to-end timeline: 6-32 weeks depending on stack

Straight from clients

What technical teams say after launch

Ijjad completely transformed our online presence. Our new website generates 3x more inquiries than the old one, and we finally rank on the first page of Google for our main keywords. The team understood our market and delivered exactly what we needed.
Business Owner, Riyadh
We needed a website and mobile app on a tight scope. Ijjad gave us enterprise-quality work at a scope that made sense for a startup. Karam personally oversaw every detail. Couldn't recommend them more.
Startup Founder, Amman
Our online store went from barely making sales to processing 200+ orders per month after Ijjad rebuilt it. The storefront, Mada integration, and mobile experience are exactly what our customers wanted.
E-Commerce Manager, Jeddah
We launched our online catalog with cash-on-delivery and ZainCash in one checkout. The reconciliation dashboard alone saved us a person on the team. Orders are up materially since the rebuild, and the Arabic checkout actually feels native — not like a translated template.
Retail Founder, Baghdad
Discovery on Monday, scoped proposal Tuesday morning, signed Wednesday. The trilingual MVP shipped on time and Sorani Kurdish was a first-class language from day one — not an afterthought. Our diaspora users in Frankfurt and Toronto stayed engaged because the page weight is small.
SaaS Founder, Erbil
We needed governorate-level shipping rules, RFP-friendly service pages, and a site that loads fast on 4G in southern governorates. Ijjad delivered all three in five weeks. Their COD ops walk-through was the difference between launch and a half-built dashboard.
Logistics Operator, Basra

FAQ

Custom web solutions — the technical questions teams ask

How is this page different from /web-development-services and /website-cost-estimator?

web-development-services is the pre-discovery hub for teams evaluating us. website-cost-estimator is the scope-tier overview for any web project. This page is the post-discovery technical deep-dive: which stack we pick when, how the architecture document looks, and what production deployment includes. Read this when you already know you want a custom platform and want the engineering detail before scoping.

Which stack does Ijjad pick for a custom web platform?

Default: Next.js + TypeScript + Postgres on Vercel or Netlify. For content-led platforms: Sanity, Payload, or Strapi as headless CMS. For PDPL-strict Saudi work: same stack, but on STC Cloud or Mobily in-Kingdom. For multi-region B2B: edge-deployed Next.js with country-aware routing. The stack scales from 4-week MVP to 4-year enterprise platform without rewrites.

When does Ijjad recommend NOT using Next.js?

Drupal-mandated procurements (we refer to Sprintive). SAP/Oracle-driven enterprise rollouts where the web is one tile (Mozon Technologies fits better). Pure WordPress maintenance retainers (DSTeck-class agencies). Mobile-only products without a web surface. We say so explicitly — forcing the wrong stack costs a rewrite in year two.

What does a typical architecture document include?

Stack choices with rationale, data model (entity relationships + indexing strategy), API contract (OpenAPI or GraphQL schema), authentication/authorization model, integration points (payment rails, ERP, CRM, AI APIs), deployment topology, observability plan (logs, metrics, traces), and risk register. Signed off before sprint 1; no code starts until the architecture is reviewed.

Do you handle API design and third-party integrations?

Yes — about 35% of our custom-platform work is integration-heavy. Payment rails (Mada, STC Pay, Tabby, ZainCash, Stripe), ERP/CRM (SAP, Odoo, Zoho, HubSpot), AI APIs (OpenAI, Claude, Gemini), document workflows, courier APIs (Aramex, regional Iraqi couriers). Every API is versioned, documented (OpenAPI + Postman collection), and tested with end-to-end scenarios.

What does "scalable architecture" actually mean in practice?

Concrete things: connection pooling on Postgres (pgBouncer), Redis or CDN edge caching where it matters, queue-based background jobs (BullMQ, Inngest), read-replica strategy when traffic justifies it, and observability so you can find the bottleneck. Not just "we picked microservices." Most platforms scale fine on a single well-tuned monolith for years.

Do you take over half-built projects?

Yes, about 15% of our intake. The standard rescue process: codebase audit (Loom walkthrough in 5 business days), salvage assessment, stabilisation sprint scope, then feature work quoted separately. We'll tell you honestly if the codebase is worth saving. Sometimes the right call is a clean rewrite; sometimes incremental works.

What does post-launch ops look like?

Runbook covering deployment, rollback, incident response, common failure modes, and on-call rotation. Observability dashboards (Datadog, Grafana, or Sentry depending on scope). 30-day on-call window included. Optional maintenance retainer for ongoing security updates, monitoring, incident response, and incremental feature work. Month-to-month with 30-day notice — no lock-in.

Ready to architect the platform?

20 minutes on a technical call. Architecture document in 5 business days. Mock server running by end of week 1.