This is a foundational role — the first engineer of its kind here, on a product early in its life. There is a large amount of ground to clear and no established playbook. You'll define the discipline as you build it.
The people implementing on our new platform — developers at agency partners in most cases, in-house teams at direct customers in others — are building design systems and websites and connecting those sites to third-party services: commerce platforms, identity providers, analytics, search, consent management, industry-specific backends. Your job is to make that work easier. Not by doing it for them — we provide the materials so clients can do it themselves. "Materials" is deliberately broad: documentation and guides, scripts, AI skills, connectors, reference implementations, and example widgets with integrations already built in (which are really just reference implementations in another form).
How the work arrives: our sales engineer learns that a client is about to implement against a particular system — say, BigCommerce. You, the SE, and the client then work out the list of materials that would make that implementation easier, and you build them. The one-off then becomes reusable: what you built for one client's BigCommerce integration is the starting kit for the next one.
The mix of writing versus coding will shift over time. Early on, it's probably more writing — guides and documentation — with the coding share growing as patterns repeat and reference implementations accumulate. We honestly don't know the long-run split, which is why we need someone genuinely strong at both.
Scope enablement needs per implementation. Work with the sales engineer and the client to identify what would make an upcoming implementation easier, and turn that into a concrete build list.
Write documentation and guides. Clear, tested, step-by-step material that a developer who has never talked to you can follow to a working result.
Build reference implementations and example widgets. Working examples with real integrations built in — the fastest way to show a client how something is done is to hand them a version that already does it.
Build connectors and adapters. Where a category is a long tail of vendors rather than one dominant player, build the flexible pattern plus worked examples rather than betting on a single vendor.
Build scripts and AI skills. Tooling — including agentic AI skills — that automates or accelerates the repetitive parts of implementation work.
Generalize from one-off to reusable. When a solution gets built for one client, capture it so the next client with the same need starts from a kit instead of from scratch.
Feed product. You'll see, before anyone else, which needs recur often enough to become real platform features. Make that case with evidence.
Qualification
A pragmatic
Required
Strong full-stack engineering skills with real depth in the modern JavaScript ecosystem — Next.js and React specifically.
Writing ability that matches your engineering ability. Especially early, much of this job's output is written material — and it has to work for a developer you'll never meet.
Comfort building with AI tooling as a first-class part of the workflow, including agentic coding tools and building reusable AI skills.
Comfort with ambiguity and greenfield work. There is no existing library, no established process, and no one who has done this job here before. You'll need to decide what to build, in what order, with imperfect information.
Ability to work directly with client developers — at agencies and in-house — patient, clear, responsive.
A pragmatic, ship-it disposition. The materials need to be solid enough that clients trust them and fast enough that they exist when the implementation needs them.
What success looks like in the First 90 days
You've scoped and delivered enablement materials for several live implementations, working the SE-client-you triangle.
A client developer has completed an integration using your materials without hands-on help from you.
The beginnings of a reusable library exist: the first guides, reference implementations, and skills, organized so the next implementation starts from them.
The product team has received at least one evidence-backed recommendation about what should graduate from enablement material to platform feature.
