If you’re into baking, you may have heard of parbaked bread. This is where you bake your bread to about 80% done and then rapidly freeze it for transportation or storage. When you finally need your bread, you complete that remaining 20% of baking. Parbaking is how many grocery stores can have fresh-baked bread without skilled bakers.
In software development, we often build products from first principles. But what if we could use the concept of parbaked with software? Could we have some components already built, focus the remaining 20%, and quickly end up with bread (or good software)?
We could never get 80% for all the software that we write, but there are some common components we could mostly reuse across projects.
What aspects of our systems could be parbaked?
- Build pipelines
- Solution set up
- Dynamic Forms
- Dynamic Data Grids
- Dynamic Dashboards
As an example, we’re tasked with creating some dynamic forms. These forms’ requirements go way beyond anything that can be done with a cookie-cutter form builder – they are complex user experiences. While building these from bare metal isn’t difficult, they are time-consuming. But if we had some parbaked pieces we could pull in, we could focus on the more difficult parts and decrease the overall development time.
Some of these problems can be solved with existing technologies. But even with those solutions, there is still some time left to set them up. If we take our parbake approach with them, it’s possible to get those solutions from 40% done to as much as 80% done. This reduction in time could add up.
I’ve been thinking about this a while and believe there are some opportunities with this approach. This has resulted in a series of posts where I build some parbaked components and share some of my thinking along the way.
Stay tuned. The first of these parbaked components will be a dynamic form system built in Angular.