After deciding that the flashcard application would become part of my DP-100 preparation, I quickly discovered something important:
- The learning engine was ready.
- The content was not.
- Actually, neither was the user interface.
The application had originally been designed around a very different type of study material.
Dog grooming exams involve terminology, procedures, anatomy, breeds, tools, and regulations.
Technical certification exams are a different world entirely.
- Questions are longer.
- Explanations are longer.
- And perhaps most importantly, understanding why an answer is correct is often more valuable than simply memorizing it.
Fortunately, one of the advantages of building the system using object-oriented principles was that I didn’t need to redesign everything from scratch.
The learning engine itself was already flexible.
What I needed was a new specialization.
A new type of deck.
A new way of presenting information.
And a better experience for someone spending hours every day reviewing technical concepts.
That someone happened to be me.
The first challenge was screen space:
- Certification questions often contain significantly more text than the content I had originally designed the application for.
- The flashcards needed to remain comfortable to read on an iPad, laptop, and desktop monitor.
- Long questions had to be displayed clearly.
- Long answers had to remain readable.
And I wanted the interface to stay clean rather than feeling like a wall of text.
The second challenge was something I considered even more important.
Explanations.
When I study, I rarely stop after finding the correct answer.
I want to know:
- Why is this the correct answer?
- Why are the other options wrong?
- What common traps exist?
- Which Azure service is often confused with another?
- What assumption did the question try to test?
The original application had no concept of extended explanations.
Now it needed one.
So I introduced an additional information section that could hold detailed notes, reminders, and context directly beneath the solution.
The flashcard was no longer just a question-and-answer pair.
It was becoming a miniature learning environment.
The third challenge appeared once the number of cards started growing.
Rapidly.
A few cards are easy to manage.
A few hundred cards are not.
What began as a single deck soon became a collection of topics.
- Machine Learning concepts.
- Azure Machine Learning.
- Responsible AI.
- Model deployment.
- MLOps.
- Data preparation.
And many others.
At that point, the application needed to support multiple smaller decks instead of one giant collection.
Studying became more focused.
And finding specific topics became significantly easier.
There were also many smaller improvements.
- Answer validation became more forgiving.
- Whitespace issues needed to disappear.
- Capitalization differences shouldn’t punish a correct answer.
- Multi-line responses had to be handled properly.
The goal wasn’t to test typing accuracy.
The goal was to support learning.
Every small improvement moved the application a little closer to that goal.
Eventually, the changes reached a point where I felt comfortable saying:
The learning engine is ready.
Again.
This time not for dog grooming students.
This time for me.
And for a completely different challenge.
There was only one thing missing.
The cards themselves.
And creating them turned out to be far more difficult than writing the code that displayed them.
In the next chapter, I’ll talk about the most time-consuming part of the entire project: building a personal knowledge base from Microsoft Learn content, workshops, practice exams, notes, and countless hours of study.