Details:
Job Description
Senior Frontend Engineer - Enterprise Web Applications
About The Role
We are looking for a
Senior Frontend Engineer with strong architectural instincts to design, build, and maintain enterprise-grade web applications from the ground up. You will own the frontend architecture end-to-end: from initial scaffolding and developer tooling to production deployment on containerized platforms. The ideal candidate is someone who can take a blank repository and deliver a well-structured, scalable, and maintainable single-page application that integrates seamlessly with backend APIs and real-time data streams.
What You'll Do
- Architect frontend applications from scratch using Next.js (App Router) and React with TypeScript in strict mode, making deliberate decisions about project structure, state management, and data flow.
- Design feature-based module architectures that keep domain logic isolated, composable, and easy to extend as the product grows.
- Build real-time interfaces powered by WebSocket streaming, including chat/conversational UIs, live dashboards, and server-sent updates.
- Integrate with heterogeneous backend APIs: Java/Quarkus microservices (REST + WebSocket) and Python/FastAPI services, defining clean API client abstractions, typed contracts, and centralized endpoint management.
- Design and implement typed WebSocket protocols with multi-phase message streaming, reconnection logic, state machines for connection lifecycle, and progressive UI rendering as data arrives.
- Implement data visualization dashboards using charting libraries (Recharts, Plotly, or similar) with interactive drill-downs, filtering, pagination, and export capabilities.
- Build enterprise data interfaces: working with SQL query results, financial datasets, time-series data, and analytical structures to create meaningful, intuitive UIs.
- Set up and maintain the CI/CD pipeline for the frontend: Dockerized builds, Nginx configuration for SPAs, Helm charts, and deployment to container orchestration platforms (OpenShift/Kubernetes).
- Establish and enforce code quality standards: ESLint flat config with zero-warning policies, consistent naming conventions (kebab-case files), and automated linting gates in the build pipeline.
- Build authentication and multi-tenancy flows, integrating with corporate SSO (OAuth2/SAML via proxy sidecars) and implementing user-scoped data access patterns.
- Create reusable component libraries following design-system principles (e.g., shadcn/ui patterns, Tailwind CSS theming with CSS variables, accessible and composable primitives).
- Collaborate cross-functionally with backend engineers (Java and Python), understanding their API patterns, constraints, and data models to design optimal integration strategies.
Job Requirements
Details:
What We're Looking For
Must Have
- 5+ years of professional frontend development experience.
- Expert-level TypeScript - strict mode, discriminated unions, generics, proper type narrowing. You treat types as documentation and contracts.
- Deep Next.js & React knowledge - App Router, layouts, server vs. client components, static export, streaming, Turbopack.
- React state management at scale - Context API composition, provider hierarchies, and knowing when not to reach for Redux/Zustand.
- Tailwind CSS proficiency - utility-first styling, custom theming with CSS variables, responsive design, and class merging strategies (clsx + tailwind-merge).
- WebSocket experience - building robust real-time clients with reconnection logic, typed message protocols, state machines, and streaming UX patterns (progressive rendering, loading states, error recovery).
- REST API integration mastery - designing typed HTTP clients, centralized endpoint registries, error handling middleware, request/response type contracts, and handling different content types.
- Backend integration fluency - ability to read and reason about backend code (Java/Quarkus or Python/FastAPI) to unblock yourself, debug integration issues, and co-design API contracts without constant backend engineer dependency.
- Build & tooling fluency - pnpm, ESLint 9 flat config, PostCSS, Turbopack, and understanding how these tools compose together.
- Containerized deployment - writing multi-stage Dockerfiles for Node.js apps, Nginx configuration for SPAs (routing, CORS, reverse proxy), and Helm chart basics for Kubernetes/OpenShift.
- Git workflow discipline - clean commit history, branch strategies, PR reviews, and CI gate awareness.
Nice to Have
- Experience with data-heavy dashboards - tables with sorting/filtering/pagination (@tanstack/react-table), charts, and data export capabilities.
- Familiarity with enterprise authentication patterns - OAuth2 Proxy sidecars, SAML flows, reading forwarded identity headers (X-Forwarded-Email, X-Forwarded-User).
- Knowledge of animation libraries (Motion/Framer Motion) for polished UI transitions.
- Exposure to backend ecosystems - familiarity with Quarkus (Java), FastAPI (Python), or similar frameworks; understanding REST principles, reactive/async patterns, and how backend architecture affects frontend design.
- Experience with runtime configuration patterns for environment-agnostic static deployments (injecting config post-build via runtime scripts).
- Experience writing mock/stub layers to enable frontend development independent of backend availability.
- Understanding of PostgreSQL/SQL - ability to interpret query results, understand joins, aggregations, and time-series data for building appropriate UI representations.
How You Think
- Architecture-first: You think about folder structure, module boundaries, and data flow before writing the first component.
- Convention over configuration: You establish naming conventions (kebab-case files, PascalCase components), enforce them with tooling, and document them for the team.
- Self-documenting code: You prefer expressive names and clear abstractions over inline comments.
- Pragmatic minimalism: You pick the simplest solution that solves the problem - React Context over a state library when it's sufficient, direct imports over barrel files, co-located types over scattered .d.ts files.
- Quality as a gate, not an afterthought: Zero-warning lint policies, type safety, and clean builds are non-negotiable for you.
- Contract-driven development: You define TypeScript interfaces that mirror backend DTOs (Java records, Pydantic models), and you advocate for API contracts as the single source of truth between teams.
- Cross-boundary empathy: You design interfaces that gracefully handle backend latency, partial results, and error states. You understand that the frontend is the last mile of a complex pipeline.
Tech Stack Summary
Layer
Technologies
Framework
Next.js 16 (App Router, static export), React 19
Language
TypeScript 5.9+ (strict mode)
Styling
Tailwind CSS v4, CSS variables, shadcn/ui component patterns
State
React Context (composed providers), no external state library
Real-time
WebSocket with reconnection, streaming message protocols
Data Viz
Recharts, Plotly, @tanstack/react-table
Icons / Motion
Lucide React, Motion (Framer Motion)
Package Manager
pnpm
Linting
ESLint 9 flat config, zero-warnings policy
Deployment
Docker (multi-stage), Nginx, Helm, OpenShift/Kubernetes
CI/CD
Jenkins pipelines
Auth
Corporate SSO (OAuth2 Proxy sidecar X-Forwarded-* headers)
Backend Ecosystem
Java/Quarkus (REST + WebSocket),
Python/FastAPI (REST)
What Sets This Role Apart
This is not a build pages from Figma role. You will be the
technical owner of the frontend platform - making foundational decisions that shape how the entire team builds features for years to come.
You'll work alongside
Java/Quarkus backend engineers building enterprise microservices and
Python/FastAPI developers building data processing APIs. The backend stack includes reactive/async patterns (Mutiny in Quarkus, async/await in FastAPI), WebSocket streaming, PostgreSQL databases, and containerized deployments on OpenShift.
Your job is to bridge these worlds - building frontends that integrate seamlessly with multiple backend technologies, handle real-time streaming gracefully, and present complex enterprise data in intuitive, performant interfaces.
,
