The 2-Week Headless Pilot: Proof Before You Decide

Enterprise decisions run on data, not promises. That's why we built the 2-week pilot: you get production-grade proof before you commit. No slide decks with pretty charts. A working prototype, real metrics, your data.

Why a pilot, not a presentation or a demo

The usual enterprise tech purchase goes like this: the vendor shows a demo on ideal data, promises results, asks for budget. Three to six months later, reality turns out to differ from the demo. The budget is spent and the result is in question.

A pilot solves three problems at once:

• Lower risk: you see how the technology behaves with your data, your catalog, your load, before you sign a contract.
• Proof of value: not "we promise +30% to speed," but a concrete measurement: "TTFB was 720 ms, now it's 110 ms on your catalog of 15,000 SKUs."
• Stakeholder alignment: the CTO sees the architecture, the CMO sees speed metrics and SEO potential, the CFO sees the economics. Everyone looks at the same data.

No vendor promises. Your data, your metrics, your decision.

Week 1: setup and deployment

In the first week we stand up working infrastructure.

Days 1-2: audit and environment setup

• Review the current architecture: which APIs exist, which need to be built.
• Measure baseline metrics on the current site (TTFB, LCP, INP, CLS via CrUX and Lighthouse).
• Deploy the staging environment: Next.js frontend, API adapters, an Elasticsearch instance.
• Set up CI/CD for automatic deploys.

Days 3-4: connecting to your data

• Sync the product catalog from 1C-Bitrix into Elasticsearch.
• Configure API adapters to pull data (products, categories, prices, stock).
• Index the catalog with mappings, analyzers, and synonyms configured.
• Build the search endpoint with faceted filtering.

Day 5: frontend

• Deploy the Next.js frontend with a basic design.
• Wire up the catalog pages (listing, product card).
• Integrate search and filters.
• Set up SSR/SSG for SEO.

Result of week one: a working staging site running on real data from your catalog. Not a mockup, not a Figma prototype. A real frontend you can open in a browser and click around.

Week 2: testing and measurement

The second week is about proof.

Days 6-7: load testing

• Simulate real traffic: 100, 500, 1,000 concurrent users.
• Measure behavior under load: response time, error rate, CPU and memory.
• Compare against the current site under the same load.
• Identify the points of degradation and the headroom.

Days 8-9: Core Web Vitals measurement

• TTFB across all page types (home, catalog, product card, search).
• LCP: what the largest element is, and how long until it renders.
• INP: response time on filter clicks, add-to-cart, and navigation.
• CLS: layout stability during load and interaction.
• Comparison: old site vs. pilot, desktop vs. mobile.

Days 9-10: search benchmark

• Search query time (p50, p95, p99).
• Faceted filtering time.
• Zero-result rate on real queries (taken from the current site's analytics).
• Autocomplete: response time and suggestion relevance.
• Comparison with the current search across every metric.

Day 10: report and recommendations

• A before/after summary report across all metrics.
• A document describing the solution architecture.
• A full rollout roadmap with timeline and resource estimates.
• A decision framework: go / no-go / need more data.

What you walk away with

After two weeks, you have:

1. A working prototype, not a mockup. A real frontend connected to your data. You can show it to your team, your stakeholders, your board.

2. A performance benchmark with concrete before/after numbers:

   • TTFB: X ms → Y ms
   • LCP: X s → Y s
   • INP: X ms → Y ms
   • Search: X ms → Y ms
   • Filtering: X ms → Y ms

3. A scalability report: how the system behaves under load, where it degrades, how much headroom is left.

4. Go/no-go criteria: clear, measurable conditions for when it makes sense to continue and when it doesn't.

5. A rollout roadmap, if the answer is yes: phases, timelines, resources, budget.

What the pilot does not include (and that matters)

The pilot is a proof of concept, not production. We set the boundaries clearly:

• No production deploy: the pilot runs on staging, not on your live server.
• No data migration: we sync the catalog, but we don't move order history, users, or content.
• No custom integrations: anything beyond catalog and search (payments, logistics, CRM) belongs to the full rollout scope.
• No custom design: we use a template or adapt a basic design. Design is a separate stage.

This is a deliberate limit. The pilot exists to answer one question, "is this worth investing in?", not to ship a finished product in two weeks.

The decision framework

After the pilot, we assess the result together against three scenarios:

Green (proceed): the metrics show significant improvement, the architecture fits, the economics add up. We move to a full rollout.

Yellow (need more data): some metrics improved, some need more work. We recommend an extended pilot of 2-4 weeks focused on the problem areas.

Red (not the right fit): headless doesn't deliver a meaningful improvement for your specific case. It happens, and we say so honestly. You didn't spend six months and a large budget to find that out.

An honest assessment is part of what we offer. We don't push headless where it isn't needed.

After the pilot: the subscription model

If the answer is yes, the work runs on a subscription:

Base ($5K/month): a template frontend, regular updates, basic support, monitoring, and an uptime SLA.

Pro ($15K+/month): custom features, an extended SLA (response time and resolution time), dedicated support, priority updates.

Enterprise: custom scope, custom architecture, an SLA tied to your business processes. Discussed separately.

The subscription includes hosting, updates, monitoring, and support. No hidden charges, no "that's an extra fee" add-ons. A predictable budget, every month.

Next step

Book a 2-week pilot. We take no more than three pilots a month, so each one gets the team's full attention. You'll get a working prototype, real metrics, and a basis for the decision, in two weeks instead of six months of discussion.

Product: Headless commerce on Next.js and Elasticsearch