Our first real dive into Magento 2 was in late 2017 and, as it is the case with many programmers who start working with a new platform, it was a pick up as you go process. Sure we read the docs and the fundamentals course materials, sure we tried to understand the whys, but we were more focused on the how. We started closing down Jira tickets in no time.
Magento offers a gazillion features out of the box and the big, enterprise projects that we took on needed more work on integrations and migrations as opposed to fundamentally altering existing behaviors. For those reasons, our work took us to the land of building on top of the existing platform and rarely inside the mysterious, sometimes messy, world that lies behind service contracts.
We had this constant feeling that something might be missing. When the Magento Professional Developer Certification came out, we looked over the study guide and quickly realised that there were still some untravelled roads to walk before we could call ourselves proficient Magento developers.
When the head of our department offered us the opportunity to take some time to study for the certification, we immediately took it and used it to cover as much unfamiliar ground as possible. Our main goal was not the certification itself but to cement all the topics covered in the curriculum. We had a ‘problem’ and we pride ourselves in being very good at fixing them, so we went in the lab (two unused desks in a quiet place in our busy building) and started hatching a plan to pass this milestone.
We started with the official free exam study guide, available here. The guide lists the topics covered in the certification exam, further broken down into subtopics. For example:
Using this guide as a basis, we built a Confluence page tree, with a dedicated child page for each major theme in the exam. An individual child page looked like this:
The structure of the child pages mirrored the subtopics in the exam. After the structure was in place, we took each subtopic and added information we found relevant in an expandable Confluence macro. The reason we hid the content was to force ourselves to pause and think about the answers before seeing them, thus avoiding the illusion of competence.
The material we added to the subtopics was based on:
- 1. the Magento devdocs.
- 2. the SwiftOtter study guide.
- 3. Vinai Kopp’s Mage2 TV videos, which we wholeheartedly recommend.
- 4. Branko Ajzele’s Magento 2 Developer’s Guide.
- 5. a github repository for certification notes.
- 6. our practical experience.
After the resource gathering phase, the plan was the following:
- 1. revisit each Confluence document and build code examples and quizzes based on every subtopic;
- 2. review and improve each other’s work;
- 3. take the quizzes until satisfied that we’ve mastered the material.
Considering that the exam is recommended for developers with at least 1.5 years of hands-on experience with Magento 2, which we didn’t have (Victor technically did, but he mainly worked on problems not covered in the exam, e.g. migration or message queues), we estimated that it would take us around 3 months to prepare. It eventually turned out that we needed less: we started preparing in mid-May and took the exam in mid-July.
In the first stage of this phase, we started building quizzes based on the resources we’d gathered. When translating learning material into questions, we tried to keep in mind Vinai Kopp’s talk,, mainly the fact that questions are scenario-based.
We initially used an internal application to create questions for our quizzes, but later settled on an idea we came across in this article, namely using slides for question-answer pairs. For example:
Compared to the quiz application, which showed us which answers we got wrong only after completing the entire quiz, this approach had the advantage of immediate feedback. Also, using slides enabled us to have open questions, add tips and extra information, and use diagrams to clarify some answers.
In the end, we built sets of slides for every relevant exam subject:
In the next phase, we started working on code examples. We didn’t get around to making a concrete example for each subtopic, as we originally intended, but we did write examples for the topics that we had little or no experience with. We found that building examples yourself is a great way to learn, but you must account for the fact that it is very time-consuming and it carries the risk of leading you astray from your purpose with unrelated bugs or newly discovered features.
Another good way to become familiar with the codebase is by setting breakpoints in strategic places and following the execution path. This is especially useful for mastering topics like request flow.
In addition to the slides and code examples, another strategy we employed was regularly getting together to discuss every topic that either of us found difficult or confusing. We also took some time to talk through the technical guidelines, trying to figure out the reasons behind the recommendations and the potential consequences of not following them.
On the day preceding Victor’s exam, we bought the SwiftOtter practice test and completed it twice, going through both unique question pools. The quiz encouragingly said we would likely fail, which meant we had at least a million-to-one chance to pass, and, as we all know, these chances crop up nine times out of ten.
When signing up to take the exam, there are two options: taking it online or at a Kryterion testing center. The latter option was easier from our point of view, so we made an appointment at a dedicated testing center in Cluj-Napoca. After we scheduled the test, we received a list of instructions for the day of the examination (e.g. have your test taker authorization code with you, arrive 15 minutes early, have two forms of identification). We were also sent a reminder the day before the examination (as if we could forget!).
The exam itself was quite difficult, with several ambiguously worded questions. You will need hands-on experience to answer some questions, as they cover situations you can only encounter when working with the code. We were, however, pleasantly surprised to see that there were no trick questions and that all the concepts targeted by the exam were indeed listed in the study guide.
In the end, we both passed on our very first try!
In our “getting certified journey” we found a whole new world that was hiding in plain sight. Parts of this world include, but are not limited to, the Magento Devblog (see a great article here), the Magento Community engineering YT channel or the incredibly good content that Vinai Kopp produces (who fully deserves to be mentioned twice).
Certifications are notorious for having a short shelf life and with the speed that Magento, an already huge platform, is growing, being certified does not mean much if you don’t constantly keep an eye on the direction the platform is heading and occasionally review existing flows and implementations.
Deciding to take the exam forced us to get outside the scope of our daily tasks and look at the big picture. We intend to preserve that mentality and always keep in mind that Magento and its community are way bigger than our current project, even if it is a big enterprise monster.
Getting into the habit of going beyond what is required of us by either keeping an eye on the official channels or diving deep in the core is the biggest edge this certification gave us.