First of all, I would like to thank Gruden for sending me to the Sitecore Helix workshop. It’s a two days workshop, which delivers in-depth knowledge of the principles, conventions and guidelines governing solution architecture, recommended development practices, DevOps strategies and more.


If you are also interested in this course, you can find more details here.


James Hirka, Solutions Architect from Sitecore, is the presenter. I’m not going to cover all the course material here, but instead highlight some important concepts that are covered within the course.



I would like to start by proving some background about what is Helix.

  • Helix is a an official guideline, recommending a modular build for Sitecore solutions
  • Habitat is an example implementation of Sitecore, using the Helix principles.

Habitat is a great starting point of learning Helix.  You can find the Habitat solution on GitHub.


Sitecore Helix was derived from the concept of components in a component-based architecture; this was originally described in the book “Agile Software Development by Robert C.Martin”.  The word component refers to a module in Helix, this is really all the files, views, renderings, configuration etc. that make up a component (or module). 


How we define a module/component? There are two major principles:

Cohesion Principles – Granularity

The principles of component cohesion is for deciding how to partition classed into components

  • REP (The reuse/release equivalence principle)
    The granule of reuse is the granule of release


  • CRP(The common reuse principle)
    The classes in a component are reused together. If you reuse on of the classes in a component, you reuse them all.


  • CCP(The common closure principle)
    The classes in a component should be closed together against the same kinds of changes. A change that affects a component affects all the classes in that component and no other components.

and Coupling principles – Stability

The principles of component coupling is for defining the relationships between components.

  • ADP (Acyclic Dependencies principle)
    Allow no cycles in the component dependency graph.


  • SDP (Stable Dependencies principle)
    Dependant in the direction of stability


  • SAP (Stable-Abstraction principle)
    A component should be as abstract as it is stable.

Favour composition over inheritance

  • Avoid multipurpose fat interfaces
  • Think of interfaces as roles
  • Implement just the minimum interface to ensure that you only depend upon what is required
  • Only expose what is required by a specific client


Practice makes perfect

I hope I didn’t put you to sleep with this very technical topic, and the principles it covered, however if you would like to work through some excises and get familiar with the Helix principles, you can find some here.   


Recommended Readings

Apart from the Sitecore Helix official documentation, there are some good books listed below:

[1] https://www.amazon.com/Agile-Principles-Patterns-Practices-C/dp/0131857258

[2] https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882

[3] https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215