By Miguelángel on February 17, 2025
A high-end jewelry manufacturer producing both collections and custom orders was scaling rapidly. Their engagement ring product family represented the majority of sales (70%+) and was becoming the operational bottleneck. Each incoming order introduced variations such as finger size, stone dimensions, prong and basket configurations, pavé patterns, and special requirements that required manual rebuilds.
The business decision was clear. Demand was rising and the catalog was expanding, but the company wanted to avoid hiring additional 3D designers. Instead of increasing headcount, the goal was to automate the engagement ring production cell so existing designers could focus on higher-value work: custom orders, exceptions, and new collection designs.
Outlier3D was deployed as the production layer behind engagement ring SKU generation, shifting repeatable modeling from manual CAD labor to validated, programmatic generation.
Before automation, the team operated from a reference-based SKU library. Models and reference images were stored on a local server. When a new order arrived, the team would pull a similar reference model and rebuild geometry to match the new specifications.
That approach worked at low volume but became fragile under scale for two reasons.
A. The standards were not actually standards
The manufacturer had strong design intent, but much of it existed as implied rules living in designers’ heads and communicated informally to new hires rather than documented in tech sheets or enforced in CAD definitions.
As a result, different designers could interpret the same engagement ring SKU differently. Over time, small deviations accumulated across orders, including shifts in proportion, curvature interpretation, clearances, and manufacturing-critical assumptions.
B. Data and order inputs were not consistently clean
Upstream order specs and reference inputs varied in quality and completeness. This increased rework loops and made scaling with more people even harder.
The conclusion was that hiring would only multiply interpretation drift. The system needed a shared, enforceable definition.
Automation depends on explicit standards. The first major phase was converting tacit design intent into documented, enforceable rules.
BD Outlier worked directly with the production team to:
This output became a design contract for the product family. It defined what is allowed to vary, what must remain fixed, and how manufacturing constraints are enforced.
A key outcome was that standardization did not only enable automation. It also produced cleaner, more consistent design outputs, even before full rollout.
Once standards existed, we encoded them into rules that reproduce reliable geometry across variations.
Rule categories included:
We also defined controlled flexibility for real-world variance. Custom stones and edge-case orders require flexibility within approved bounds. For those cases, we defined which relationships can stretch, which constraints remain strict, and which cases require dedicated parameter sets.
The solution was implemented as a library of SKU-specific computational definitions. Each SKU family has a dedicated definition that regenerates geometry and outputs from structured inputs. This turns a SKU into a repeatable generation engine.
Each definition supports a tailored input set. Some SKUs accept minimal parameters (for example, finger size). Others accept complex inputs such as custom stone dimensions, configurable patterns, and order-specific controls. File-based inputs can also be supported when required by the workflow (for example, STL inputs).
To keep the system maintainable, the definitions are built from modular computation blocks. Modularity reduces iteration time, increases reuse, and isolates changes. Reusable modules typically include:
Operationally, raw inputs are normalized into internal parameter data, rules and exception pathways are applied, geometry is computed, and outputs are generated according to the SKU’s export contract. Outlier3D handles execution and debugging of these definitions so the pipeline remains reliable for production use.
Once deployed, SKU generation runs as a deterministic pipeline:
Definitions follow a strict release process: internal testing, extreme scenario testing, client review of standards, and final approval. After approval, definitions are deployed into the client’s Outlier3D account for ongoing internal use.
Client users log in and see a table of production-ready SKUs. Selecting a SKU reveals its input panel (text, numbers, and file inputs where required) and the expected output information. After generation, different departments consume whichever outputs they need. Some teams rely on CAD formats, others rely on STL outputs, and others use structured result data such as stone counts, part counts, and production notes.
Outlier3D becomes the centralized production system so departments operate on synchronized geometry and specifications.
Early adoption had predictable friction. Designers were accustomed to manual modeling and initially saw automation as extra steps rather than a production system.
Adoption accelerated once two things became true:
Once the system was producing consistent geometry under real orders, adoption became natural rather than forced.
Before Outlier3D, throughput was bounded by manual labor, interpretation, and rework loops.
With Outlier3D, as definitions are standardized and rolled out, generation time drops to compute time (seconds), plus the operator’s time to input parameters and hand off outputs .Consistency improves because every variant originates from the same enforceable definition.
Remaining failure modes shift away from silent geometry drift and toward visible upstream issues such as invalid inputs, missing specs, impossible dimensions, or corrupted meshes. This is a healthier failure mode because it is detectable early and correctable systematically.
Capacity impact is already meaningful. Even partial adoption can cover output comparable to a full-time designer for this product family. As more of the engagement ring parameter space is standardized and encoded, throughput scales without requiring additional headcount.
Challenge: inconsistent legacy references
Some CAD references conflicted with each other. We normalized them into a single enforceable standard per product family.
Challenge: standards living in people’s heads
We translated tacit knowledge into documented rules with the production team, creating a formal design contract.
Challenge: exceptions and edge-case stones
We implemented controlled flexibility with approved bounds and clear exception pathways, plus flags for extreme inputs.
Challenge: performance on complex geometry
We handled performance through modular design, targeted optimization, and isolating expensive operations.
Each definition is validated before deployment through structured testing and client sign-off. BD Outlier runs extreme scenarios across the parameter space (size extremes and edge inputs) and reviews ambiguous cases with the client.
A standardization report is delivered for approval so the enforced rules align with manufacturing requirements and brand intent. Outlier3D also flags runtime errors and extreme geometry conditions, including cases that may not be visually obvious at first glance.
Every generated SKU includes structured output data that describes what was produced (components, counts, and SKU-specific notes). The goal is that errors, when they occur, come from missing standards or invalid inputs rather than silent geometry drift.
The system is modular, so adoption accelerates over time. Reusable computation blocks reduce the effort required to onboard new SKUs, and changes can be made at the module level without destabilizing the pipeline.
Collections that share construction patterns can be standardized and expanded quickly. As more products become standardized, production becomes more predictable, collisions decrease, and internal teams gain more time for creative work and high-value custom orders.
The deployment of Outlier3D reshaped the client’s 3D production pipeline. Manual modeling was replaced with an automated, standardized system capable of generating SKU variations with consistent geometry and reproducible specifications. Modeling labor dropped to near zero for defined products, operational friction across teams decreased, and production capacity scaled far beyond what was feasible with manual workflows.
With a dedicated generation engine governing each SKU family, the client now produces faster and with a level of reliability that manual workflows struggle to maintain. This infrastructure supports growth without increasing headcount while reallocating internal talent toward custom work, complex pieces, and new collection development.
In practice, this means design decisions stop living in people’s heads and start existing as systems—scalable, auditable, and repeatable across the entire production pipeline.
If your team is buried in repetitive SKU variations, we can help you standardize your product logic and deploy a pipeline that generates production-ready outputs in seconds, while preserving design intent.
We partner with category leaders to streamline their 3D workflows at scale and without compromise.
