Front End Developer (Alabang)

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 Youll Do

• Architect frontend applications from scratchusing (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 interfaces
• 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 Were 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 & 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 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 its sufficient direct imports over barrel files co-located types over scattered . 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.

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