Hire developers Community Blog Find a dev job Log in
Close menu
Tech insights: How Senior Developer Renaldo Meere Learns by Trial and Error
Take the 2022 State of the Software Developer Nation survey to get more data on dev salaries and careers. Take the survey

How Senior Developer Renaldo Meere Learns by Trial and Error

By Gabi Immelman

Most of us don’t like making mistakes, but trial and error can be a very effective method of problem solving and error reduction, especially for devs.

Renaldo Meere, Senior Solutions Architect at OUTsurance, shares when and how he uses trial and error for deeper learning, how it’s helped him in his career, and how he cultivates space for learning from failure.

OfferZen_mindjoy_Renaldo_Computer-built-from-parts_Inner-article-image

What’s learning by trial and error?

Learning through trial and error is, to put it simply, a method of problem-solving. Within computing, error reduction is a particular way of learning by trial and error. Renaldo began learning this way in Grade 8 when his father brought home spare computer parts and said, “There you go… See if you can make something work.”

Renaldo, who’d never seen the inside of a computer and didn’t have a computer of his own, put two computers together within four days, completely by trial and error, way before internet tutorials existed!

Renaldo continued to use trial and error as a form of self-learning throughout his 21-year career, and likens it to resistance training where resistance is framed as a positive opportunity for growth.

Using trial and error for low-stakes problems

The key here for Renaldo is appropriate resistance. For example, there is more room for learning through failure if a problem has low-stakes. You need to identify the scope for failure before it has impact. The potential impact of failure should dictate how much you can adopt trial and error into your project.

In cases when the impact of failure can be potentially detrimental to the project, Renaldo’s advice is to play it a little more safe. “The critical thing about this is finding the balance between when you can fail, and when you can’t fail.” One of the ways to ensure your failure doesn’t have massive, project-ending consequences is to break bigger tasks up into smaller ones.

“Let’s say, for example, I didn’t do proper research on a particular thing and I wrote a piece of code which nobody picked up and I ended up leaking data into the system. That’s a pretty massive thing to go wrong,” he explains. “If that was broken up into smaller chunks where I was allowed to actually properly explore my solution, I would have very likely found the failure in the solution.”

That way, you can fail on the small tasks and learn from them without significant repercussions for the bigger project.

Smaller chunks of work are easier to get feedback on, and make error reduction easier because there’s a smaller gap to close than there would be in a larger project.

How Trial and Error can benefit developers

The tech industry, Renaldo notes, already has structures in place that lend themselves to learning from multiple failures. Testing is a great example of this, because it’s supposed to point to any failures with the aim of reducing errors until a successful solution is reached.

Each iteration is an opportunity to learn something and understand the problem better. Part of iterating for success is not aiming to be right because the learning is found in the process of error reduction.

Rather than working towards a narrow definition of “right” or “perfect”, work towards solutions with high levels of accuracy and plans to recover from any potential problems. To fully embrace learning, you need to be open to multiple failures.

Renaldo notes how this learning mindset has positively contributed to his many hobbies and has made a positive impact on his non-work life.

“I started painting a few years ago and the first painting was horrible. I realised 5% into this that this wasn’t going anywhere, but I had to then make the choice of either just pushing through it or just throwing it in the bin and carrying on with something new. And I decided to push through it.“

“The reason I did that was to see, first of all, if I could correct what went wrong in the first place. And then, secondly, there is also experience to be had in finishing.” Each iteration allowed Renaldo to isolate mistakes and improve on previous versions.

How to reframe failure as learning

Of course, letting go of wanting to be “right” and being ok with failing is difficult. We’ve all been conditioned to avoid failure and mistakes, so how do you change this mindset and embrace failure as a way to learn?

“It’s not personal. It’s very, very important to disassociate yourself with your professional self and code. It’s not you failing; it’s your code failing.”

Being able to make this separation allows you to focus on the problem and come up with solutions. For Renaldo, being honest with himself was the biggest hurdle he had to overcome to find and be ok with this distance.

“You have to be honest and admit when you mess something up, and just carry on. Everybody messes up, but not everybody knows how to recover from it. The more you do it, however, the better you get.”

When mentoring developers who struggle with this distance, Renaldo has seen that people need to convince themselves that failure isn’t personal. And, usually this happens when he opens up a developer’s solutions with them to interrogate what is or isn’t working in an amicable, low-stakes way.

“So for me … it starts at that level, and it starts with actually teaching juniors how to monitor themselves. Because, that immediately lowers the defensive barriers and pulls emotions out of the way because it’s my unit tests that says I’m messing something up here. You also need to be aware of the fact that if you want to do it properly, you need to fail at it.”

Renaldo encourages junior developers to adopt a mindset where they’re willing to risk failure in order to progress and innovate.

Being curious about how many failures it takes to succeed will ensure you’re doing something properly, because in order to make progress, you have to be willing to risk something. Going in thinking that you need to succeed the first time means you’re setting yourself up for fewer opportunities to practise. Many iterations lead to mastery.

Creating spaces for failure and learning

As a senior developer, Renaldo has and continues to mentor junior developers and aims to cultivate systems and environments that encourage failure and learning. By encouraging failure, “companies actually gain more self-sufficient people.” Processes, such as having multiple eyes on the same project or ensuring people can fail at smaller tasks without massive implications, create low-risk environments that are optimised for learning through trial and error.

A low-risk environment is a space where teams are comfortable with getting things wrong and have the space and time to learn by trial and error. Low-risk environments also allow for discovery, novel solution-finding and deeper understanding. And how does Renaldo create this environment for his team? By leading by example and showing that failure is ok.

This means being upfront about what he doesn’t know. “This is also explicitly done by me so that other people can guide me,” he explains.

Renaldo has created a space for his team to engage on questions and ideas, even when they don’t agree; it’s a collaborative, interactive process where being wrong isn’t framed negatively. In fact, failure is encouraged because it leads to better solutions!

When failure isn’t framed as something that must be avoided, developers can explore paths that align with their curiosities without fear or hesitation. This allows for many possible solutions.

Most, if not all developers, are natural problem-solvers, so iterating and learning by trial and error shouldn’t be too foreign. But, it still takes a lot of effort to reframe failure as a learning opportunity.

If you’re just starting out on that learning journey, Renaldo encourages failing as much as you can, moving on from it quickly and ensuring you don’t take it personally.

To reduce errors, you have to make them in the first place. Thomas Edison, when asked about the 1000 “failures” that preceded a successful lightbulb famously responded that these weren’t failures at all, but that his invention just had 1000 steps. So, go ahead and fail, learn and hopefully have your lightbulb moment!

Join our Programmable Banking Community to learn more about trial and error with Renaldo. You can join here or send us an email.


Gabi is the Founder of Mindjoy an EdTech start-up based in Cape Town, South Africa, where kids ages 8 to 12 can learn to programme using projects.

She is curious about 🧠learning, 🚀startups, 🏀resilience, 🛁systems thinking and fascinated by the quest for the 🦾master algorithm.

This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.

Subscribe to our blog

Don’t miss out on cool content. Every week we add new content to our blog, subscribe now.

By subscribing you consent to receive OfferZen’s newsletter and agree to our Privacy Policy and use of cookies.