Staff Frontend Engineer - Commerce

Publish the Commerce frontend standard: architecture, state, data fetching, testing, accessibility, and performance. Every Commerce team adopts it.

Instrument real-user monitoring on every Commerce surface. Publish field metrics for LCP, INP, and CLS per surface, with an owning team for each.

Review frontend pull requests across Commerce. Raise the quality of every one you touch, and write down the patterns so reviews scale beyond you.

Map the central frontend platform roadmap against Commerce needs. Agree a working contract with that team: what the platform provides, what Commerce builds, and how requests and contributions flow both ways.

Set up a standing design review with the central platform team, so Commerce decisions and platform decisions stay aligned.

Produce a frontend hiring plan: how many engineers, at what levels, and in what order.

Ship the architecture that lets every Commerce team build and deploy its surfaces independently, with enforced module boundaries. Build it on the central platform's foundation wherever one exists, and close gaps jointly with that team.

Put performance and bundle budgets in CI for every Commerce route. A regression fails the build.

Make accessibility a gate: automated checks in CI and manual audits on checkout and storefront flows against WCAG 2.2 AA.

Land typed, generated API clients end to end, so a backend contract change breaks at compile time.

Contribute at least one Commerce-built capability to the central platform, adopted by another organization.

Hire and onboard the first Commerce frontend engineers.

Commerce storefronts meet "good" Core Web Vitals at the 75th percentile in field data, on mid-range mobile devices.

Checkout and storefront pass a WCAG 2.2 AA audit.

Backend engineers ship frontend features that meet the standard without your direct involvement.

Coding agents across Commerce follow the frontend standard by default, through shared instructions, skills, and review gates you designed.

Commerce is HighLevel's reference implementation for frontend excellence. Its standards, performance budgets, and agent guidance reach other organizations through the central platform.

You lead or co-lead HighLevel-wide frontend decisions with the central platform team, written as RFCs other organizations build on.

The Commerce frontend team runs on its own. You spend your time on the next hardest problem at HighLevel.

You have 9+ years of experience in building frontend systems

You have built commerce surfaces at scale: storefronts, checkout, or point of sale.

You have built or led a design system consumed by many teams, and shipped breaking changes through it safely.

You have used ConnectRPC, gRPC-Web, or protocol buffers from the browser.

You can read and write Go well enough to build or review a backend-for-frontend.

You contribute to open source, web standards discussions, or the frontend community.

You have taught backend engineers to ship good frontend code.

You have contributed to a shared frontend platform or design system used by several product organizations.

Frontend. Vue.js across HighLevel. TanStack Query for server state. Webpack and Rspack for builds, with micro-frontends where teams need independent deploys. Contracts. ConnectRPC with protocol buffers from the browser to the backend. The client calls typed functions and receives typed responses. No hand-written REST clients. Backend. Go services on Kubernetes, with Postgres as the primary store. Backend-for-frontend layers run inside the cluster, close to the services they call. Rendering. Static generation where content allows it, client-side rendering for interactive surfaces, and a backend-for-frontend to aggregate data. You will challenge and refine this direction with evidence. Engineering practice. Every engineer works with coding agents. Standards live as written documents, shared agent instructions, and review gates.

Scope. You have owned frontend architecture across several teams for a multi-quarter effort. Other teams still build on decisions you made. You can show us the before and after. Platform partnership. You have worked with a central platform team as both a consumer and a contributor. You influence roadmaps you do not own. You negotiate scope with evidence. You land changes in shared code that many organizations depend on, without breaking them. You have taken a standard from one team and made it company-wide. The browser platform. You know the rendering pipeline, the event loop, and what makes a long task. You follow new platform features through Baseline and MDN, and you have shipped some of them. You reach for the platform before a library, and you have deleted dependencies because the browser made them unnecessary. Performance. You diagnose with field data, performance traces, and network waterfalls. You have moved Core Web Vitals in production and kept them there with budgets and ownership. You can explain where every millisecond of a page load goes, from DNS to interaction. Architecture for many teams. You have designed systems where many teams deploy independently into one product. You know module federation, native ES modules, import maps, monorepos, and when each one fits. You know what each costs: duplicate dependencies, runtime integration bugs, build infrastructure. You pick deliberately. Data and contracts. You design how the client talks to the server: backend-for-frontend layers, typed RPC contracts, caching, and invalidation. You understand why twenty sequential calls over the public internet cost seconds, and how to collapse them. Accessibility. You build with semantic HTML first and add ARIA only where semantics fall short. You know WCAG 2.2, colour contrast requirements, and keyboard and screen reader behaviour. You have led an accessibility audit and fixed what it found. Security. You treat user-generated content as hostile. You know XSS, content security policy, sandboxed rendering, and supply chain risk in the npm ecosystem. Code review. Your reviews make engineers better. You find the race condition before the naming nit. You turn repeated feedback into lint rules, patterns, and documentation. AI-assisted engineering. You use coding agents every day with discipline. You write the context, specs, and skills that make agent output match the standard. You verify generated code with tests and review. You have a view on how teams keep a codebase understandable when everyone generates three times more code. Writing. You write design documents and decision records that other engineers can act on without a meeting.

The company is an Equal Opportunity Employer. As an employer subject to affirmative action regulations, we invite you to voluntarily provide the following demographic information. This information is used solely for compliance with government recordkeeping, reporting, and other legal requirements. Providing this information is voluntary and refusal to do so will not affect your application status. This data will be kept separate from your application and will not be used in the hiring decision. We encourage you to review our Privacy Policy before submitting your application