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).