01
The answer is a combination, not a product
A routine has to make sense as a set. Recommending one apparently suitable product is not enough if the full combination creates conflicts or unnecessary overlap.
Owned venture / Ecommerce & custom systems
RoutiscaCommerce System.
A Shopify personalization layer that turns customer inputs and compatibility rules into an editable routine connected to purchase.
- Brand
- Routisca
- Year
- 2026
- Role
- Owner · Product · UX · Development
- Platform
- Shopify + custom backend
- Type
- Ecommerce / Custom system
Live product experience
Routine Builder / Shopify
Case-study scope
This case study covers the personalization and commerce flow that is live or demonstrably built. Routisca's newer operations backend is still evolving and will be added only as those systems ship.
01 / The problem
The catalogue could show products. It couldn't decide the routine.
Skincare shoppers often know what they want to improve, but not which combination of products makes sense for their skin, concerns and existing routine. A normal ecommerce catalogue leaves the customer to solve that decision alone.
The opportunity was not another recommendation quiz that ends with a generic bundle. The system needed to collect meaningful inputs, enforce hard rules, assemble a compatible routine, keep it editable and then connect the answer back to real products in Shopify.
02 / The challenge
Personalization only works if the rules survive every change.
02
Hard rules have to survive personalization
Skin concerns and preferences are useful inputs, but exclusions and compatibility rules have to take priority. The system needs to reject unsafe or conflicting replacements rather than simply maximize choice.
03
The catalogue keeps changing
Recommendations have to work with real Shopify products rather than a fixed mock catalogue. Product attributes, availability and routine roles all affect eligibility.
04
Editing cannot break the routine
A generated routine is only useful if the customer can adapt it. Product swaps therefore need to be re-checked against the rest of the routine before they become selectable.
03 / The approach
Separate product data, decision rules and interface state.
The storefront is the interface, but it is not the source of truth for the decision itself. Product attributes and routine roles are structured so the recommendation layer can reason about eligibility before the UI presents a choice.
Shopify metafields cover product-facing attributes such as concern, skin type, texture, usage time and routine step. Additional logic data supports exclusions, ingredient-specific hard rules and compatibility checks. The matching process is deterministic and rule-based; it is not presented as AI.
Product layer
Live Shopify catalogue + structured product metadata
Logic layer
Eligibility, exclusions, conflicts and matching rules
State layer
Customer inputs, saved routine and selected replacements
Interface layer
Questionnaire, result, editing and purchase actions
Compatibility-aware editing
Replacement flow
04 / How it works
A recommendation is a pipeline, not a single score.
- 01
Customer inputs
- 02
Hard-rule filtering
- 03
Compatibility checks
- 04
Product matching
- 05
Editable routine
- 06
Purchase flow
A customer moves through a seven-step intake. Their answers establish skin context, concerns and hard exclusions. Products are filtered and checked as a routine, then the result stays editable under the same rule system.
When a customer requests a replacement, the system does not simply show similar products. The candidate has to remain compatible with what is already selected before it becomes an eligible choice.
05 / The solution
A routine customers can understand, keep and change.
Instead of ending at a product recommendation, the flow returns an ordered routine with usage context and commerce actions. Customers can revisit the result, replace eligible products and skip steps for items they already own.
Generated routine
Editable result
Routine result
Desktop experience
06 / Key functionality
The questionnaire is only the front door.
01
Guided intake
A multi-step flow captures skin type, concerns, routine context and ingredient-specific hard rules before any recommendation is produced.
02
Compatibility-aware matching
Eligibility is evaluated across the routine rather than treating each product recommendation as an isolated decision.
03
Safe product changes
When a customer changes a product, replacement options are checked against the existing routine and only compatible choices can be selected.
04
Owned-item skipping
Customers can indicate that they already own a product or do not need a step, keeping the routine useful without forcing every recommended item into the purchase.
05
Saved customer state
The result is persisted through the custom backend so a routine can be revisited through its unique link instead of disappearing at the end of the session.
06
Commerce connection
The generated routine is connected back to the buying journey so customers can move from guidance into purchase without rebuilding the selection manually.
07 / UX / CRO decisions
Reduce uncertainty without removing customer control.
- 01
Ask for decisions in context
The intake breaks a complex skincare decision into smaller steps instead of presenting a dense form or asking customers to interpret product chemistry on their own.
- 02
Make the result editable without making it fragile
Customers get agency over the generated routine, but the system continues enforcing compatibility when a replacement is requested.
- 03
Respect products the customer already owns
The experience allows steps to be skipped when the customer already has something suitable. That makes the system behave like guidance rather than a forced bundle.
- 04
Keep guidance attached to the routine
The result includes usage direction and routine context so the output is more useful than a product list and remains understandable after the initial session.
08 / Technical implementation
Shopify handles commerce. Custom logic handles the decision layer.
The customer-facing experience lives inside Shopify, while a custom PHP/MySQL backend persists routine state and supports the logic that does not belong in theme presentation code. JavaScript connects the interactive storefront flow to that backend and to the products customers can actually purchase.
This keeps Shopify responsible for catalogue and commerce while the custom system owns personalization state and business rules. The newer operational backend is being expanded separately and will be added to this case study only as those parts ship.
- Storefront
- Shopify · Liquid · JavaScript
- Product data
- Metafields + compatibility attributes
- Backend
- PHP · MySQL
- Integration
- Shopify APIs + custom endpoints
- Persistence
- Customer and saved-routine state
09 / Result
A live decision-support layer inside the store.
The shipped system changes the shopping journey from browsing products independently to building a routine through guided decisions. It preserves customer choice while keeping replacements inside the same compatibility logic.
Success here is documented through shipped functionality and usable operational capability rather than unverified revenue or conversion uplift claims.
- 01Live multi-step Routine Builder inside the Shopify storefront
- 02Rule-based product eligibility and routine compatibility checks
- 03Compatibility-safe product replacement flow
- 04Saved routines with persistent customer state and unique links
- 05Support for skipping steps when products are already owned
- 06Direct path from the generated routine back into ecommerce purchase
10 / Gallery
Three points in the live flow.
01 / Guided intake
Customer context02 / Safe replacement
Compatibility checked
03 / Routine output
Guidance + commerce12 / Start a conversation
Need something similar? Let's talk.
If the problem sits somewhere between ecommerce UX, business rules, integrations and custom development, tell me what needs to work better.