Skip to content

Admin dashboard development on the same API as your app

Next.js and TypeScript dashboards for the content, users and permissions behind your app or site, running on the same API the app uses. The Escore dashboard runs tournaments, matches, rankings and news.
Typical timeline
3–6 weeks
Deliverables
7
Updated
2026-10-05

Admin dashboard development is the other half of most apps we build: the screens where your team manages content, users, roles and permissions. Mahmoud Hamdy builds them in Next.js and TypeScript, and the rule he follows is simple. The dashboard and the app run on one API, so the data and the business rules live in one place. We are two engineers working remotely from Menoufia, Egypt, for clients in Egypt and the Gulf, and we have built dashboards for Escore, for the IAI store assistant on Salla and for Ihkam.

Admin dashboard development for Escore, on the app's own API

Escore is a live esports platform we built over a year for Rov Group, a Saudi company. Mohamed Magdy wrote the Flutter app; Mahmoud built the backend and the dashboard. Editors use it to create tournaments and generate their brackets, manage matches, team and player rankings and news, and administer user accounts.

The backend is a modular monolith: one Node.js and Express process split into 16 modules, each with its own routes, controllers, services and models. They cover tournaments and brackets, matches, team and player profiles, rankings, news, transfers and access control. We chose that over microservices because it keeps the parts of the system cleanly separated without the operational cost of running many services, a cost a small team does not need to carry.

The dashboard and the Flutter app consume the same REST API. When an editor publishes a news item or corrects a result, the app reads it from the same source, with no sync job between two databases. Live match events reach the app through a WebSocket layer running alongside the HTTP server.

Why one API for the app and the dashboard

Give a dashboard its own database or its own API and you write validation and permission rules twice; sooner or later the dashboard accepts something the app rejects. One API gives every rule a single home.

It is also what makes adding a dashboard to an existing app a matter of weeks. If your app's API is documented, we build on it. If it lacks what the dashboard needs, we add that to the same API rather than bolting on a side server.

Permissions are checked on the server, not in the UI

Hiding a button does not stop anyone from sending the request directly, so permissions are enforced on the server for every request.

Escore has five roles: Super Admin, Admin, Editor, Team Manager and Viewer. The access layer enforces each role's limits on the API routes themselves; a verified team manager, for example, edits their own team's profile. Sign-in uses short-lived access tokens with encrypted refresh tokens.

This site's own dashboard follows the same idea. Sign-in is Google only, an account gets in only if its email is already on the admin list, and every server action checks for an admin before it writes anything.

A dashboard for a store owner who does not code: IAI

IAI is an AI assistant that answers customers of a Saudi 3D-printing store on Salla, in Arabic, through a chat widget on the store and a Telegram bot. The owner is not a developer, so the Next.js dashboard shows conversation logs, a breakdown of what customers ask about, and how accurate the answers are.

From the same dashboard the owner edits reply templates and sets the escalation rules that hand a conversation to a person when the assistant is not confident, without touching code. The answers themselves come from the store's knowledge base and from products and orders read through the Salla API, with frequent answers cached. The dashboard and the bot service live in one Turborepo and share TypeScript types and the Salla API helpers, so the two sides never disagree about the data.

Review tools in Ihkam

Ihkam is an Arabic web platform for people who have memorized the Quran, live at ihkamquran.com since September 2026 and built entirely by Mahmoud. It publishes 1,090 groups of near-identical verses, each confirmed by a classical source. Content that sensitive needs a human in the loop, so the platform includes admin tools for reviewing groups and handling error reports. Data sits in PostgreSQL on Neon through Drizzle, with sign-in through Better Auth.

Timeline and what moves it

For an existing app, adding a dashboard or backend takes 3 to 6 weeks and ends with documentation your developers can pick up. Built together with a new app, the dashboard is part of the 6 to 10 week first release.

What moves it most is the number of roles, how many kinds of data the dashboard manages, the state of your current API, and any external data source. In Escore, scheduled jobs pull data from PandaScore, GRID and Abios at configurable intervals and normalize it before it is stored, so editors work on clean records.

The dashboard runs on your own hosting accounts and the code is yours from day one. After launch we fix bugs in what we delivered, against the agreed scope, free for 30 days.

Typical timeline
3–6 weeks
Tools we use
11
Projects
3

What you get

  1. A Next.js and TypeScript dashboard in Arabic and English for content, users and permissions
  2. Roles and permissions checked on the server on every request, not just hidden buttons
  3. One API that both the app and the dashboard read from, or a dashboard wired to your existing API
  4. Data pulled in from external providers or from your store platform where needed
  5. Deployment on your own hosting accounts, with the source code in a repository you own
  6. API and dashboard documentation your developers can pick up
  7. Free fixes for 30 days after launch for bugs in what we delivered against the agreed scope

Tools we use

Typical timeline

Durations in weeks. The hatched part is the minimum; the dashed part depends on the scope.

Projects where we did this

Projects
3
  • Website, 2026

    Ihkam

    An Arabic web platform for people who have memorized the Quran. It finds exactly which near-identical verses a memorizer mixes up, shows them side by side with the difference highlighted, and schedules daily review until they stick.

    • Next.js
    • React
    • TypeScript
    • Tailwind CSS
  • AI assistant

    IAI

    An Arabic AI customer assistant for a Saudi 3D-printing store on Salla. It answers shoppers on the store's web widget and on Telegram from a searchable knowledge base, with live store data and an admin dashboard.

    • Node.js
    • OpenAI API
    • Anthropic API
    • Telegram Bot API
  • Website

    Bagour Delivery

    A food delivery platform for the town of Bagour in Menoufia, with customer, driver, restaurant and admin apps and real-time order dispatch. In development.

    • Node.js
    • TypeScript
    • Socket.IO
    • MongoDB

Why clients trust us

What you can count on from the first call until well after launch.
  • You own the code and accounts

    The source code repository, the Google Play and App Store developer accounts, and the server, cloud and domain accounts are in your name from day one. We work in them with access you grant, and they stay with you if we stop working together.

  • An NDA before you explain

    We sign a non-disclosure agreement before you explain the idea, not after the first meeting.

  • 30 days of free fixes

    For 30 days after launch we fix, free of charge, any bug in what we delivered against the agreed scope. New features, scope changes, and problems caused by third-party services or by someone else's changes are not covered.

  • Optional monthly support plan

    A set number of engineering days each month for fixes, store updates, performance work, keeping an eye on production and new features when needed, with priorities agreed at the start of each month. It is paid, and the price is on request.

Questions about this service

Questions
6

Tell us what you want to build

Message us on WhatsApp or send a short brief, and we reply with a proposed scope and a rough timeline. If you want a rough duration first, try the estimator.