What 3 years of mentoring taught me

I started my tutoring business in 2020. The lockdowns were in full swing, lots of people were using the downtime to switch careers. This got me thinking: I should start a business teaching people to code. When I was 14, I taught my brother's friend who did web design at uni how to code. It was an awesome experience and taught me so much.

I started with a very diverse client base: a range of skill levels from total beginners to mid and senior developers who needed an extra brain to think with. It made me realise how many different skills are involved in mentoring (to name a few!):

  • Reducing complex problem solving into small steps, making them more approachable

  • Teaching with empathy and respect for the learner. Everyone has a different learning styles and experiences, so adapting your method to the person is key.

  • Walking your student through your thinking process, and teaching them to show theirs. This is 90% of teaching the core coding skill: problem solving.

What I learnt over my 1000+ hours of teaching

Working with each skill level taught me something new. I firmly believe that everyone from all backgrounds and skill levels has something to teach me, and this has proven it!

Teaching beginners

As a senior, you take your knowledge for granted: you understand variables, for loops and the difference between arrays and objects. Someone new? They know little to nothing. But, you get to teach them the fundamentals, and watch as their understanding grows. They start off overwhelmed, but as you help build their understanding, they take on more and start experimenting outside their comfort zone.

Teaching beginners makes you think about how you code and why. A beginner will look at 2 blocks of code that do the same thing, and ask why one approach over the other? You get to teach them to think about they differ, and why one might be better. Another way of doing this was by demonstrating a mistake, and getting them to point out what might be wrong with it, helping them grow their problem solving muscle.

Teaching people to walk through and spot problems, is building the skill central to coding: problem solving. My students have learnt so much from me by pointing out mistakes in my code, and walking me through why it won't behave the way it should. This has taught me the importance of showing colleagues that their contributions are important, because you never know what others will spot that you won't.

It's not just problem solving or debugging, either... It's the art of project management. How do you take an idea and turn it into code? How do you make it production ready? Some beginners get so trapped in perfectionism, that they don't start their passion project. I found success in helping them to develop an MVP, then figure out improvements! After all, the more projects someone can take on (and finish!) the faster their skills and confidence will build.

Teaching beginners, I learnt that programming isn't just languages or syntax. They're irrelevant. What coding truly is, is problem solving, project management and communication skills. Beginners can get so caught up in syntax and learning the language, that they forget the true skills are all the above.

Teaching mid-level

Teaching mid-level developers is awesome. They understand fundamentals, now they're applying them autonomously. They just need support with implementation: what tools? How do we make it scaleable? Which infrastructure choices are best?

I love working with them on projects, and guiding them and suggesting different approaches. Seeing them figure out which ones are best for them and their project is an awesome sight, you're watching them build the experiences they need to build reliable solutions in realtime!

Working with mid levels showed me that: if your fundamentals aren't sound, you'll struggle to apply your skills to new challenges. It also opened my eyes to how we should teach developers about sustainability:

  • Are you going to understand this code in 2 weeks time? Can others understand it?

  • Is it performant?

  • Does it work reliably?

  • Is the code self documenting?

These are so important, often forgotten parts of the learning process. Because in my experience if you skip any of these, you end up stuck. Your bottleneck becomes the fact you're not writing readable code, or that its not self documenting.

Transferrable skills

All these experiences have enriched communication skills. It's driven me to show my thinking to a range of different skill levels and backgrounds, helping me describe my thought process in an accessible way.

It's also helped me learn about project management. I've helped so many students manage their projects from start to finish, even starting businesses with them!

It's taught me about common pitfalls: Working with so many developers has taught me to spot common mistakes that lead to vulnerabilities, and how to avoid them.

But most of all? It's taught me the importance of leading with empathy and patience. People don't like to feel incompetent, they don't like feeling frustrated, and so many have fraught education experiences. I've learnt to adopt a teaching style that I hope centers patience, kindness and curiosity. All essential qualities for fostering a good learning experience, ones I wish I had from my mentors growing up.

Conclusion

When I started tutoring, I thought it'd be a nice side gig, with supplemental income. But it turned into working with people from across the globe, from America, to Dubai. With a diverse range of skills and backgrounds, each having something to bring to the table.

I'm so grateful for these experiences. I'm so proud to have kickstarted careers and to have helped setup my student's startups in my time tutoring.