Product configurator development in the UK can mean anything from a guided selector to a production tool that prices, visualises and submits a valid order. Those are different projects. Before choosing a framework or commissioning polished screens, decide which customer decision the first version must support and what evidence will show that it works.
A useful prototype makes the rules visible, exposes missing information and gives the owner something specific to test. Device coverage, accessibility and sales impact are checked later, as separate steps.
Quick Answer
Start with the smallest interactive prototype that can test the hard part of the decision. Define the permitted options, invalid combinations, output, owner approval and failure states before visual polish. Test it with representative scenarios and record exactly which browser, device, rules and routes were checked. Move towards production only after the business has checked the rules, supplied images and files it has the rights to use, and agreed what the prototype has and hasn't been tested for.
Halo’s interactive experiences service can help turn that scope into a demonstrable first build. A configurator that must later connect to a website, account or operating system may also need website development or a purpose-built internal tool.
Decision Framework: What Are You Actually Building?
Choose the first version by the uncertainty it needs to remove:
- Guided selector. A short question route recommends a category or next action. Use it when buyers struggle to choose, but final pricing or specification remains human-led.
- Rule-based configurator. The interface allows only permitted combinations and produces a reviewable specification. Use it when compatibility rules are known and stable enough to encode.
- Visual prototype. A 2D or 3D experience demonstrates layout, colour, parts or interaction. Use it to test comprehension and presentation, not to imply manufacturing accuracy unless the underlying model has been validated.
- Transactional configurator. The result passes a valid configuration, price and customer choice into checkout, quoting or operations. This is production integration, not merely a richer prototype.
If the answer depends on uncertain rules, begin with the rule model. If the risk is whether people understand the interaction, begin with a clickable or coded experience. If the risk is operational handoff, prototype the output and approval route before adding elaborate visuals.
Define The Decision Before The Interface
Write one sentence that completes: “The user needs to choose ___ so that ___ can happen.” Then list:
- Inputs the customer supplies.
- Options the business controls.
- Combinations that are impossible, unavailable or merely unusual.
- Calculations and assumptions.
- The output the customer sees.
- The record the business receives.
- The point where a person must review or approve the result.
This prevents a beautiful interface from hiding an undefined commercial rule. The product owner—not the developer—should confirm prices, compatibility, dimensions, availability, terminology and what happens when no valid result exists.
Prototype Evidence And Its Limits
A prototype receipt should identify the version, route, viewport or device, scenarios and date checked. Useful checks include a permitted configuration, a rejected combination, reset and back behaviour, an incomplete route, keyboard navigation and the final handoff.
Treat that evidence as covering those checks on that version only. Test on real phones as well as desktop, run a proper accessibility review rather than relying on a keyboard pass, check each product rule against the spec, and follow a test enquiry through to ordering and fulfilment before calling the configurator ready.
For an example, Halo’s work page shows MANOR, an interactive prototype built to test an experience before any production decisions. The proof approach explains how Halo reports what a prototype has and hasn't been tested for.
Accessibility And Device Checks
Interactive controls need more scrutiny than a static page. Test focus order, visible focus, keyboard operation, labels, error recovery, zoom, reduced motion where relevant, touch target spacing and layouts at narrow widths. The W3C’s mobile accessibility overview explains how established accessibility standards apply across mobile devices, while its keyboard guidance gives a useful baseline for functionality that must not depend on a pointer.
Treat these as design and test inputs. A formal accessibility claim needs an agreed standard, representative coverage, documented testing and remediation.
Rules, Assets And Rights
The owner should verify every product rule against a controlled source and record who approved it. Give important rules stable identifiers so a later change can be traced. Decide how the experience behaves when price, stock or compatibility data is missing rather than silently guessing.
Supply only assets the project is permitted to use: product images, logos, typefaces, CAD files, audio and brand material all need clear ownership or licence terms. If the prototype uses generated or placeholder media, label it as such and replace it before making product-accuracy claims.
What To Send Halo
Send a bounded decision problem rather than an open request to “make a configurator”:
- The product or service choices and the person who owns their accuracy.
- A redacted rule table, sample specification or current manual process.
- The hardest valid and invalid scenarios.
- Required devices, browsers, languages and accessibility target.
- The intended output: recommendation, saved design, quote request or order data.
- Rights-cleared visual assets or a clear placeholder plan.
- The evidence needed before the project can progress.
Use the existing app or tool audit route for a current experience, or send a configurator project brief for a new build. The AI audit-flow guide can help reduce an unclear request to one testable first slice, and the proof-ledger guide shows how to keep claims tied to receipts.
Next Step
Choose three representative scenarios: an ordinary valid choice, a difficult valid choice and an invalid choice. Write the expected output and approval point for each. That gives Halo enough to recommend whether the next artefact should be a rule map, clickable prototype, coded configurator or production integration plan—and what each stage needs to prove.
FAQ
How much does product configurator development in the UK cost?
It depends on the stage. The main cost drivers are:
- Discovery and rule mapping: how many options, combinations and exceptions need to be written down and checked.
- Prototype: whether a simple guided selector is enough, or you need a rule-based, 2D or 3D interface.
- Production build: pricing logic, saved designs, accounts, and connections to your website, quoting or order systems.
- Testing and launch: the devices, browsers and accessibility standard you need covered.
Halo prices each project from a project brief, so starting with a discovery or prototype stage lets you see real costs before committing to a full build.
Should I start with a no-code prototype or custom code?
Use the lightest method that tests the main uncertainty. No-code can suit a simple question route; custom code may be justified for unusual interaction, complex rules, performance or integration. The prototype method does not determine whether the final system is production-ready.
Can a configurator guarantee more conversions?
No. It may make a complex choice clearer, but conversion depends on traffic, offer, price, trust, usability and measurement. Any uplift claim needs comparable analytics and an agreed attribution method after launch.
Who is responsible for product rules and pricing?
The business owner should approve the source rules, prices, compatibility and exceptions. A developer can encode and test supplied logic, but cannot infer commercial or engineering truth from an incomplete brief.
What proves that a configurator is ready for production?
Production readiness needs agreed rule coverage, device and browser checks, accessibility work, security and privacy review, monitored integrations, recovery behaviour and owner acceptance. A prototype walkthrough is useful evidence, but it is not that full release record.
