Roof Top-Up: Parametric Design System

2024 · 4 months

Computational Designer, Technical Lead

Grasshopper backend for a prefab roof configurator: product families defined as JSON data, geometry built to stay responsive in real time, and production drawings plus BOM generated from the same source.

The problem

A prefab roof manufacturer's catalog lived in drawings and expert heads. Turning it into an online configurator meant translating a complex product range, roof variants, opening layouts and production rules, into a system that stays trustworthy without a designer checking every output.

The constraint

The geometry had to stay responsive in real time for an online configurator while still carrying production detail, and the product families were defined by tacit knowledge the manufacturer had never written down.

What I built

A Grasshopper backend where product families are JSON data rather than code, so a new type is a data entry instead of a code change. Geometry is created without placement and positioned by planes afterwards, which made the system repeatable. Drawings and BOM come out of the same source as the 3D model. Profiling drove the performance work: no solid operations, decomposed steps, structured data trees throughout.

Role

Computational designer and technical lead. I owned the architecture, the data model, the geometry system, the validation layer, and the client sessions.

Outcome

The architecture held: new product types landed as data entries, and it survived requirements shifting mid-project. What it did not survive was the distance between what the client expected and what had been scoped, so the configurator arrived technically sound and short of the impact it was aimed at. That, more than the code, is what I took forward.

Lessons learned

• Scalable architecture starts with data structure design: JSON-based product families let new product types land as data entries while staying consistent. The modular architecture held even as requirements shifted mid-project.
• Geometry creation should separate logic from placement: Building geometry without immediate placement, then using planes to position it, made the system scalable and repeatable, and improved both performance and maintainability.
• Continuous validation prevents costly mistakes: Real-time checks in the Rhino viewport and automated testing through the GhValidation plugin caught issues at each phase, before they became expensive to fix.

Final reflection

This project was a formative lesson in the gap between technical success and project success. I built a robust, performant, scalable system and the architecture worked beautifully, but the project didn't achieve its intended impact: expectations, communication, and requirements that surfaced too late. Technical excellence solved the wrong problems elegantly.

It also taught me that complex product digitization exposes tacit knowledge. When manufacturers describe their products they skip the details they consider obvious, and those details are exactly what a configurator needs. The fix is discovery as a practice rather than a phase: frontloaded, with frequent visual check-ins and sign-off on each phase, so hidden complexity surfaces while it is still cheap to absorb.