About the role
Ready to be the person who decides how a product feels to use? We build dense B2B interfaces: trading screens where numbers move, freight boards where a mistake costs a truck its afternoon, support consoles used by people who know the domain far better than we do.
You'd own the front end of one client product: architecture, component library, and the standards everyone else codes to. TypeScript and React, usually Next.js, per-client design systems instead of a specification document.
Engagements run six to eighteen months, so you live with your decisions. That's the only reliable way to find out which ones were any good.
Everyone here uses agents. You'd set how your team uses them: where they speed things up, where they make a mess, and what still needs a human eye.
What you'll do
- Set the direction. Rendering strategy, state, data fetching, and the dull conventions that keep a codebase readable at month nine.
- Build the hard parts. The virtualized table, the live chart, the form with forty states. Then leave a pattern the team can follow.
- Raise the floor. Daily reviews, types that catch real mistakes, tests where they earn their keep, and no ceremony for its own sake.
- Face the client. Sit in demos, explain a trade-off to their CTO, and change your mind in public when they turn out to be right.
- Hand it over properly. Documentation and a walkthrough that leave their team able to carry on without us on speed dial.
What we look for
- Five Years Deep in React: you have shipped it, broken it, fixed it, and can talk about all three without flinching.
- Next.js Architect: rendering strategy per route, server components, caching and revalidation all decided on purpose.
- Design System Builder: a component library with tokens, variants and documentation, rather than forty one-off components with similar names.
- Opinions About the Data Layer: React Query, server component fetching or a pattern of your own, and a clear line about where state is allowed to live.
- Heavy UI Experience: virtualized tables, live charts, drag and drop, or whatever else falls apart at ten thousand rows.
- Testing Strategy, Not Ritual: Vitest, Testing Library and Playwright, pointed at the flows that carry money.
- Build Pipeline Literate: bundle analysis, code splitting, and an answer for why the vendor chunk grew by 300KB last Tuesday.
- TypeScript by Instinct: types that make wrong states unrepresentable, not decoration on top of any.
- CSS Without Fear: layout, stacking contexts and animation hold no mystery, and you can explain the cascade to a junior.
- Performance Detective: you profile before you touch anything, and you know which number a user feels.
- Accessibility as Habit: keyboard, focus, labels and contrast, from the first commit instead of the last audit.
- Client-Ready Communicator: you hold your ground with a CTO without jargon, condescension or a slide deck.
- Fluent English, Written and Spoken: most of our work happens in a written thread or on a call, and both have to be clear. Arabic is a genuine advantage across the region.
- Sets the AI Bar: you use coding agents at speed and decide where the team should and shouldn't trust them.
Personal traits
- Self-starter: nobody hands you tickets here, and you'd hate it if they did.
- Generous: you make the engineers around you better instead of hoarding the interesting work.
- Straight talker: you raise the problem early, with options attached rather than just a frown.
Nice to have
- Real-time data: websockets, streaming updates, optimistic UI that doesn't lie.
- Design systems you built and then had to maintain across several products.
- A domain where being wrong has consequences: money, freight, health.
Why you'd like it here
- Remote across MENA. Work from wherever you are in the region, with hours built around your team's overlap rather than someone's attendance spreadsheet.
- Work that ships. Products go live in weeks, not quarters. When someone asks what you have been building, you can open it on your phone and show them.
- Small teams, no ticket queue. Four to eight people carry a product from the first client call to handover. Nobody hands you a spec and disappears.
- Kit and tools you choose. A budget for your setup, and for the editor, licenses and services that make you fast. No three-week procurement saga.
- A learning budget with time attached. Money for the course or the conference, plus room in the week to use it. The second half is the part most places skip.
- Client contact from day one. You sit in the room where the decisions get made. Plenty of engineers wait a decade for that seat.
- Time off people take, and no timesheets. We measure engagements, not humans in fifteen-minute increments. Book the holiday, go, come back.
