Architecture

DPS is split into a UI layer (dashboard) and a business-logic layer (Parse Server). The dashboard owns no business logic — it calls Parse Cloud Functions for everything.

Top-level diagram

┌─────────────────────────────────────────────────────────────────┐
│                          DPS PLATFORM                            │
│                                                                 │
│   ┌──────────────────────────────────────────────────────────┐  │
│   │                     dps-dashboard                         │  │
│   │              Next.js 14 + Refine + MUI                    │  │
│   │                  (UI ONLY — no logic)                     │  │
│   │                                                          │  │
│   │   Auth (NextAuth)   Dashboard UI   Wizards   SuperAdmin  │  │
│   └──────────────────────────────────────────────────────────┘  │
│                              │                                  │
│                    Parse.Cloud.run(...)                         │
│                              ▼                                  │
│   ┌──────────────────────────────────────────────────────────┐  │
│   │                       dps-server                          │  │
│   │              Parse Server + Express                       │  │
│   │              (ALL BUSINESS LOGIC)                         │  │
│   │                                                          │  │
│   │   Cloud Functions (10 modules):                          │  │
│   │   Organizations · Projects · Apps · Deployments          │  │
│   │   Templates · Images · Activity · OAuth · Metrics        │  │
│   │   + dps-payments / dps-checkout                          │  │
│   │                                                          │  │
│   │   DPS-E Module (E-Commerce Operations):                  │  │
│   │   Billing · Payments · Logistics · Social                │  │
│   │                                                          │  │
│   │   Core: Context · Events · Providers · Repository        │  │
│   │   parse-manager: docker-orchestrator · ssh-deployer      │  │
│   └──────────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘
                               │
        ┌──────────────────────┼──────────────────────┐
        ▼                      ▼                      ▼
  Docker Registry      Consumer Apps         External APIs
  ghcr.io/duabalabs    Sellub · 3y3anaa      GitHub · Paystack
  parse-server         Landing pages         Postiz · Carriers
  sellub-server        ProxyFidelity         Netlify · Vercel
  react-web · landing-*

Design principles

Never auto-deploy — every deployment requires explicit user confirmation.
Wizard-driven — multi-step guided flows for all provisioning.
Template authority — DPS owns all template definitions and Docker images.
Consumer-agnostic — Sellub, 3y3anaa, ProxyFidelity, and the landings are consumers, not peers. They sit on top of DPS, not beside it.
Database-per-tenant — security and isolation trump resource efficiency. See Multi-Tenancy.

dps-dashboard layout

Path	Purpose
`src/app/(auth)/`	Login / register / OAuth (NextAuth)
`src/app/(dashboard)/projects/`	Project + app management
`src/app/(dashboard)/templates/`	Template gallery
`src/app/(dashboard)/billing/`	User billing
`src/app/(dashboard)/dps-e/`	DPS-E module UI
`src/app/api/auth/`	NextAuth routes (only API surface)
`src/components/apps/`	App creation wizards
`src/components/sellub/`	Sellub-specific provisioning UI
`src/components/deployment/`	Deploy target selectors
`src/lib/sellub/`	Sellub helpers
`src/types/templates.ts`	Template definitions (single source of truth)

dps-server layout

Path	Purpose
`src/parse-server/`	Parse Server core
`src/parse-server/cloud/dashboard/`	Dashboard cloud functions (orgs, projects, apps, deployments, templates, images, activity, oauth, metrics)
`src/parse-server/cloud/dps-payments/`	Paystack integration, splits, refunds
`src/parse-server/cloud/dps-checkout/`	Generic checkout pipeline (direct + vendure flows)
`src/parse-server/adapters/`	Storage / cache adapters
`src/parse-server/middleware/`	Express middleware
`src/dps-e/`	E-commerce operations (Billing / Payments / Logistics / Social)
`src/core/`	Shared infrastructure (Context, Events, Providers, Repository)
`src/core/parse-manager/`	`docker-orchestrator.ts`, `ssh-deployer.ts`, `metrics-collector.ts`

Data plane

                 ┌─────────────────────────────────────┐
                 │         dps-server (Parse)          │
                 │   App registry · Templates · Auth   │
                 │   Deployments · DPS-E · Checkout    │
                 │                                     │
                 │   Master MongoDB (DPS metadata)     │
                 └─────────────────────────────────────┘
                              │
            ┌─────────────────┼─────────────────┐
            ▼                 ▼                 ▼
  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐
  │  Tenant A     │  │  Tenant B     │  │  Tenant C     │
  │  Parse Server │  │  Parse Server │  │  Parse Server │
  │  Port 8001    │  │  Port 8002    │  │  Port 8003    │
  │  DB: db_a     │  │  DB: db_b     │  │  DB: db_c     │
  └───────────────┘  └───────────────┘  └───────────────┘

Each tenant Parse Server runs in an isolated Docker container with its own MongoDB database, dynamic external port (8000–9000), and unique appId / masterKey / javascriptKey.

Where each Duabalabs product fits

Product	How it uses DPS
Sellub	Sellub-server is a `sellub` app type provisioned by DPS. Sellub-storefront calls DPS for checkout via the `vendure` flow. See Sellub on DPS.
3y3anaa	Mobile app provisioned via the `react-native` template (Expo + EAS). Backend is a `parse-server` app type.
Duabanti	Static landing on Netlify; donation modal calls DPS via browser-direct in the `direct` flow.
Duabaconnect	Static landing on Netlify; subscription gate uses `direct` flow + `paystackPlanCode`.
Duabatrade (TBD Logistics)	Static landing on Netlify; invoice `/pay` page uses `vendure` (when channel provisioned) or `direct`.
ProxyFidelity	Type-4 integrator; runs its own Parse server alongside, calls DPS server-to-server with master key for `direct` checkouts.

Overview Supported App Types