Job Title: Senior Frontend Engineer
Location: Dubai, UAE. This is an on-site role.
Experience Required: 6+ years
We're hiring a Senior Frontend Engineer to own our two web applications: a business administration application our customers run their operations from, and a consumer-facing mobile web application their end users transact through. Both are Next.js 15 / React 19 codebases with real users and real money flowing through them. You'll set their technical direction, build the testing and internationalisation foundations they lack, and shape how thefrontend team works with coding agents.
About us
We are an IT company based in the Gulf, building and operating several software products for business customers across the Middle East. Our platforms are multi-tenant, transactional and heavily integrated: they connect to our customers' existing systems, process payments through regional providers, and give operators live visibility into their business.
We are rebuilding our core platform as a set of services and expanding the product portfolio over the next two years. The two web applications are where every one of those bets becomes visible. We'll tell you much more about the products themselves during the interview process.
The stack you'll work in
- Framework: Next.js 15 (App Router, Server Components, standalone output), React 19, TypeScript 5, Turbopack.
- Architecture: Feature-Sliced Design (app → pages → widgets → features → entities → shared), two apps of about 139k lines that share a component layer by copy today and should share it bypackage tomorrow.
- UI: Tailwind CSS v4 (CSS-first config, about 70 semantic tokens), shadcn/ui over Radix primitives, recharts, TanStack Table, a drag-and-drop layout editor.
- Data & state: TanStack Query v5 for server state, zustand v5 for local state, react-hook-form with zod, axios clients for browser and server.
- Operations: Sentry, ESLint (zero warnings), Prettier, Docker, GitHub Actions, a self-hosted PaaS.
- Backend you'll talk to: FastAPI services behind Traefik, JWT with scoped permissions, a Go payment service, and payment-provider hosted pages.
What you'll do
- Own the two apps' technical direction: architecture, conventions, dependency hygiene, the Feature-Sliced boundaries, and the extraction of the shared layer into a real package.
- Build the testing foundation from zero: These apps handle payments with no automated tests today. You'll choose the tools (Vitest, Testing Library, Playwright or equivalents), put the money flows under test first, and make the suite something the team trusts and the agents run.
- Ship Arabic and right-to-left: The API already returns language-keyed content; the apps discard it. You'll bring in an i18n framework, logical CSS properties, locale-aware number, currency and date formatting, and RTL layouts that don't look mirrored by accident.
- Build the runtime theming engine: Today a customer gets one colour, one logo and one cover image. You'll turn the existing token system into per-tenant themes, fonts, layout variants and editable copy, delivered safely with no CSS or script injection.
- Replace polling with realtime: The live operational views poll behind a "real time" badge. You'll implement SSE or WebSocket delivery with optimistic updates and correct behaviour under concurrency (two users completing the same payment at once).
- Make the consumer app fast on the phones people actually use: Core Web Vitals on mid-range Android over poor Wi-Fi, bundle discipline, and sharp decisions about the Server/Client Component boundary.
- Get money right in the UI: minor-unit formatting for 2- and 3-decimal currencies (AED, SAR, KWD, BHD), tax-inclusive and exclusive display, multi-party payment maths that agrees with the backend to the last unit.
- Payments UX: Apple Pay and Google Pay, hosted-page hand-offs, error and retry states that don't double-charge.
- Security and access control: XSS and injection hygiene, correct handling of tenant context, and RBAC route guards that match the permission model.
- Ship AI in the product: streaming conversational interfaces, AI-assisted content authoring with a human review step, and the interaction patterns that make model latency and uncertainty feel fine.
- Raise the bar: review, ADRs, mentoring mid-level engineers, and defining how the frontend team uses coding agents.
How we build
We treat coding agents as part of the team, not a novelty. This is what the software development lifecycle looks like here, and what we'll expect you to be fluent in:
- Spec first. Work starts as a written plan: the component contract, the states (loading, empty, error, partial), the edge cases, and the tests that prove them. Agents such as Claude Code implement against the plan; the engineer owns the plan and the review.
- The repo is the prompt. Each app carries agent-facing documentation: CLAUDE.md or AGENTS.md, the Feature-Sliced rules, the token system, ADRs. When an agent keeps making the same mistake, we fix the docs, not just the diff.
- Review it like it came from a stranger. Agent output ships only after a human has read it with the rigour of a junior's pull request: does it match the design, does it handle every state, is the accessibility real, did it reach across a slice boundary.
- Tests are the contract. Agents write and run tests too. Component and end-to-end tests on the payment flows are what make agent speed safe.
- Judgement about where not to. Payment hand-offs, tenant context, and anything that touches a stored token get slower, human-led work. Knowing the difference is part of the job.
Core requirements
Production ownership
You've carried user-facing applications in production, not handed them off. You've watched an error rateclimb in Sentry after a release, rolled back or hot-fixed, and written up what you changed so it wouldn't happen again. You ask "how will I know when this breaks?" before "how do I build this?"
Attention to detail
On an application that moves money, a currency formatted to two decimals in a three-decimal market, a total that rounds differently from the backend, or a button that stays enabled during a payment is an incident, not a cosmetic defect. You read the states before writing the happy path, check what the API actually returns instead of trusting its types, and notice when two numbers that should agree don't.
Engineering depth
- 6+ years building production web applications, most of it in React and TypeScript.
- Next.js App Router in production: Server and Client Components, caching and revalidation, serveractions, streaming, and the trade-offs of each.
- Server-state management with TanStack Query or equivalent: cache keys, invalidation, optimistic updates, and knowing what belongs in local state instead.
- CSS architecture at scale: design tokens, Tailwind (v4 CSS-first config a plus), theming, and RTL-safe layout with logical properties.
- Testing you actually trust: component tests, end-to-end tests, and the judgement to know which flows deserve which.
- Web performance: Core Web Vitals, bundle analysis, image and font strategy, and measuring on real devices.
- Internationalisation: you've shipped a multi-locale product and understand pluralisation, bidi text,and locale-aware formatting. RTL experience is a strong plus.
- Accessibility as a habit: keyboard, focus, semantics, contrast, screen readers.
- Frontend security: XSS, content security policy, safe handling of tokens and tenant context.
AI-native engineering
- You use coding agents daily and can show your workflow: how you write the spec, how you constrain the agent, how you verify the output, and where you stop trusting it.
- You've written agent-facing documentation for a codebase (a CLAUDE.md, AGENTS.md, cursor rules or equivalent) and can explain what made it effective.
- You've built or shipped an AI-powered interface, or can demonstrate equivalent depth: streaming responses, partial and uncertain states, human-in-the-loop review, and graceful fallback when the model is slow or wrong.
- You can articulate where agent-generated UI code is and isn't acceptable on a payment flow, and you've caught a plausible-looking wrong answer from a model in real work.
Nice to have
- Design systems at scale; Storybook or equivalent component documentation.
- Monorepo tooling (Turborepo, pnpm workspaces) and package extraction from an existing codebase.
- Realtime UI with SSE or WebSockets, including reconnection and ordering guarantees.
- PWA and service workers, offline-tolerant UI.
- React Native or native Android.
- Node or BFF layers; OpenAPI-driven client generation.
- Payments, fintech or e-commerce domain experience.
- Arabic, or experience shipping to Gulf markets.
What the first six months could look like
- Put the consumer payment flows under end-to-end tests, and make the suite a merge gate.
- Ship Arabic with a proper RTL layout on the consumer app, then the administration app.
- Deliver the first runtime theme: per-tenant tokens, fonts and layout variant, configured by the customer.
- Replace the live operational view's polling with a streamed feed.
- Write the ADR and the agent-facing docs for the shared layer, and see a mid-level engineer ship against them.
Job Type: Full-time
Application Question(s):
- What is your current monthly salary (AED)?
- What is your expected monthly salary (AED)?
- Are you available to join immediately? (If not, mention notice period)
Education:
- Bachelor's (Preferred)
Experience:
- Front-end development: 6 years (Required)
Location:
- Dubai (Preferred)
Work Location: In person