Senior Frontend Engineer

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)

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