Senior Frontend Engineer (ReactJS)

Must have tech stack

Typescript + ReactJS 5+ years of experience is must to have

HTML

designing system

development with Architect Experience must

Responsibilities :

Design and develop a high performance SaaS B2B application

Deliver products with high responsibility, availability, scalability, security, and maintainability

Work with a product owner, a designer, and backend engineers to implement product features

Translate UI / UX designs and business requirements into high-quality, well-tested, clean, simple, and maintainable code

Take a lead on technical best practices

Resolve any technical issues, risks, and challenges, escalating as necessary and providing solutions

Maintain and improve product quality.

Requirements

Must have

8+ years experience in web development

5+ years for frontend development for React / Typescript

Experience with Agile development.

Strong understanding of JavaScript fundamentals

Strong knowledge of HTML and CSS

Experience with frontend testing frameworks (Jest, Mocha, etc…)

Experience using, designing, and building GraphQL Web Service APIs

Experience in designing system architecture

Experience in designing and maintaining UI components (Stotrybook, Visual Regression Test, etc…)

Excellent English verbal communication skills.

Nice to have

1+ years experience with backend development (Golang / Java / NodeJS / Others)

Experience with CI / CD (Github workflow, Circle CI) and infrastructure (AWS, Heroku)

Container-based development (Docker, docker-compose, Kubernetes) experience

Experience with scrum master role.

Experience utilizing design systems.

Experience in utilizing state management libraries (Redux etc..)

Understanding of microfrontend architecture

Core Frontend Development (must-have)

React.js (hooks, concurrent features, Suspense, SSR / CSR tradeoffs).

TypeScript — advanced typing, generics, utility types, codebase-wide typing strategy.

Modern JavaScript (ES6+) — modules, async / await, iterators, proxies, memory / closure patterns.

HTML5 / CSS3 — semantic markup, responsive layouts, cross-browser quirks, CSS modules / CSS-in-JS (emotion / styled-components) / utility-first (Tailwind).

Layout & accessibility — ARIA, WCAG best practices, keyboard navigation, screen-reader testing.

Performance optimization — code-splitting, lazy loading, critical CSS, HTTP caching, image optimization, bundle analysis.

Client-side rendering patterns — CSR, SSR, ISR, hydration concerns (Next.js / Nuxt-like knowledge).

Component & Design System Engineering (must-have)

Component-driven design — Atomic / Feature-sliced architecture, reusable component libraries.

Storybook (authoring, docs, visual review), component catalog maintenance, semantic versioning for component libs.

Design tokens & theming — token management, runtime theming, dark mode, cross-brand theming.

Visual regression — Percy / Chromatic or similar visual diff workflows integrated into CI. (nice to have)

State Management & Data Layer (must-have)

State libraries — Redux (toolkit), Zustand, Recoil, or comparable patterns; advanced patterns (selectors, middleware, immutability).

Offline & real-time — WebSockets, Server-Sent Events, optimistic updates, cache invalidation patterns. (nice to have)

GraphQL & REST — designing / consuming GraphQL APIs (Apollo / Relay), schema awareness, batching / fetch policies.

Architecture & System Design (must-have)

Micro-frontend architecture — module federation, routing & shared runtime, version management, independent deployability.

Monorepo experience — Nx / Lerna / Turborepo setups, package boundaries, dependency graph management.

Scalability & maintainability — feature-slicing, separation of concerns, large-scale codebase refactoring.

Security-first frontend — XSS / CSRF mitigations, secure auth flows, token handling in browser, secure storage patterns.

Testing & Quality (must-have)

Unit & integration testing — Jest, React Testing Library, mocking patterns, coverage strategies.

E2E testing — Cypress or Playwright with stable selectors, parallel test strategy, test flakiness mitigation.

Contract & integration testing — schema validations for GraphQL / REST; consumer-driven contracts.

Static analysis & linting — ESLint, TypeScript compiler settings, style enforcement (Prettier), automated PR checks.

Observability & error monitoring — Sentry, LogRocket, frontend telemetry, performance monitoring (Core Web Vitals).

Build, CI / CD & Platform (must-have)

Build tooling — Webpack 5, Vite, Rollup; tree-shaking and long-term caching strategies.

CI / CD pipelines — GitHub Actions / CircleCI / Jenkins : test → build → visual tests → canary / blue-green deploy.

Containerization & infra — Docker, container-based local dev, K8s familiarity for frontends (Ingress, rolling deploys).

Package management & publishing — npm / pnpm / yarn workspaces, private registries, semantic releases.

Cloud platforms — AWS / GCP / Azure basics for frontend delivery (CDN, S3, CloudFront, IAM). (nice to have)

Observability, Ops & Reliability (must-have)

Performance budgets & SLOs for frontend features; monitoring Core Web Vitals.

Feature flags & rollout — LaunchDarkly / Unleash or self-hosted flag strategies for safe releases.

Incident response — debug production issues, rollbacks, root-cause analysis for client-side faults.

Backend & Integration

Understanding backend systems — service contracts, authentication (OAuth2 / OpenID Connect), rate limits, idempotency. (must have)

Some backend exposure — NodeJS / Java / Go basics for cross-stack debugging and building small services (nice-to-have).