Staff Frontend Engineer - Commerce

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. You write the standards. You review the code. You 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. That makes it the place to prove what excellent frontend engineering looks like at HighLevel. What works in Commerce becomes a shared capability, so every organization benefits.

The central frontend platform team is your closest partner on both horizons. They own the shared foundation. You are their most demanding customer and one of their strongest contributors. You bring Commerce requirements early. You co-design solutions with them. You 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.

The bar is high. A storefront that loads in six seconds loses the sale. A checkout a screen reader cannot use excludes a customer and breaks the law in some markets. An architecture that couples every team slows every one of them. A pattern that stays inside one organization helps only that organization. You own all four problems.

First 90 days

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

First 6 months

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

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