Front End Developer

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 scratchusing 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 architecturesthat keep domain logic isolated, composable, and easy to extend as the product grows.
• Build real-time interfacespowered 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 protocolswith multi-phase message streaming, reconnection logic, state machines for connection lifecycle, and progressive UI rendering as data arrives.
• Implement data visualization dashboardsusing 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 pipelinefor 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 librariesfollowing design-system principles (e.g., shadcn/ui patterns, Tailwind CSS theming with CSS variables, accessible and composable primitives).
• Collaborate cross-functionallywith backend engineers (Java and Python), understanding their API patterns, constraints, and data models to design optimal integration strategies.

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 patternsfor environment-agnostic static deployments (injecting config post-build via runtime scripts).
• Experience writing mock/stub layersto 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

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.