Staff Frontend Engineer - Commerce

About the Role:

You are the technical owner of every pixel a Commerce merchant or shopper sees. You also raise the frontend bar for all of HighLevel. The role has two horizons.

Commerce first. You set the architecture, write the standards, review the code, and hire the team. You hold the line on performance, accessibility, and quality while engineers and their coding agents ship into Commerce every day.

Then HighLevel. Commerce is greenfield, so it is the place to prove what excellent frontend engineering looks like at HighLevel. What works in Commerce becomes a shared capability.

The central frontend platform team is your closest partner on both horizons. You bring Commerce requirements early, co-design solutions with them, and upstream what Commerce builds so HighLevel keeps one foundation.

This is an individual contributor role at staff level. You lead through design documents, code, reviews, and the people you grow. You will write production code every week.

Responsibilities:

First 90 days

• Publish the Commerce frontend standard covering 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 and write down the patterns so reviews scale beyond you.
• Map the central frontend platform roadmap against Commerce needs and agree a working contract with that team.
• Set up a standing design review with the central platform team.
• Produce a frontend hiring plan covering how many engineers, at what levels, and in what order.

First 6 months

• Ship an architecture that lets every Commerce team build and deploy its surfaces independently, with enforced module boundaries.
• Put performance and bundle budgets in CI for every Commerce route. A regression fails the build.
• Make accessibility a gate, with 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.
• Contribute at least one Commerce-built capability to the central platform, adopted by another organization.
• Hire and onboard the first Commerce frontend engineers.

First 12 months

• 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.
• Commerce becomes HighLevel's reference implementation for frontend excellence.
• You lead or co-lead HighLevel-wide frontend decisions with the central platform team.

Requirements:

• 9+ years of experience building frontend systems.
• Built commerce surfaces at scale: storefronts, checkout, or point of sale.
• Built or led a design system consumed by many teams, and shipped breaking changes through it safely.
• Used ConnectRPC, gRPC-Web, or protocol buffers from the browser.
• Able to read and write Go well enough to build or review a backend-for-frontend.
• Contributes to open source, web standards discussions, or the frontend community.
• Taught backend engineers to ship good frontend code.
• Contributed to a shared frontend platform or design system used by several product organizations.

Our Stack & Direction:

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. No hand-written REST clients.

Backend. Go services on Kubernetes, with Postgres as the primary store. Backend-for-frontend layers run inside the cluster.

Rendering. Static generation where content allows it, client-side rendering for interactive surfaces, and a backend-for-frontend to aggregate data.

Engineering practice. Every engineer works with coding agents. Standards live as written documents, shared agent instructions, and review gates.

What you bring on day one:

Scope. You have owned frontend architecture across several teams for a multi-quarter effort, and other teams still build on your decisions.

Platform partnership. You have worked with a central platform team as both a consumer and a contributor, and 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 reach for the platform before a library.

Performance. You diagnose with field data, performance traces, and network waterfalls. You have moved Core Web Vitals in production and kept them there.

Architecture for many teams. You have designed systems where many teams deploy independently into one product, including module federation, native ES modules, import maps, and monorepos.

Data and contracts. You design how the client talks to the server, including backend-for-frontend layers, typed RPC contracts, caching, and invalidation.

Accessibility. You build with semantic HTML first and know WCAG 2.2, colour contrast requirements, and keyboard and screen reader behaviour.

Security. You treat user-generated content as hostile and know XSS, content security policy, sandboxed rendering, and npm supply chain risk.

Code review. Your reviews make engineers better, and you turn repeated feedback into lint rules, patterns, and documentation.

AI-assisted engineering. You use coding agents daily with discipline and verify generated code with tests and review.

Writing. You write design documents and decision records that other engineers can act on without a meeting.