Turning Lessons into Nuggets of Gold


11 April 2023

Software Development


Ok, let's get real - nobody likes to experience setbacks; however, the good news is, we can learn from our experiences and turn them into valuable lessons. That's where 'lessons learnt' come in. They're like nuggets of gold that we can mine from our past experiences, helping us avoid similar obstacles in the future and paving the way to success.

But hey, it's not just about achieving success, its also about making sure you:

  • Avoid costly mistakes: by scrutinising mistakes we can identify the root cause of the problem and take corrective action to prevent it from happening again.
  • Enhance productivity and efficiency: use the lessons learnt to optimise processes and strategies, resulting in improved productivity and efficiency.
  • Facilitate innovation: by analysing past successes, a company can identify the factors that led to that success and use them to drive innovation and growth.
  • Invest in knowledge sharing: lessons learnt can provide valuable knowledge that can be shared across different teams, enabling a company to leverage the collective knowledge of its employees.

Our lessons learnt

We recently facilitated a company-wide workshop aimed at discovering and sharing lessons learnt within our organisation. Through this exercise, we were able to identify several high-level lessons that can help us to improve our business practices and remain competitive in the market. Without getting into the nitty-gritty, here are the top gems we uncovered.

1. Use the right tool for the job

If you've ever tried to hammer a nail with a spoon (no judgement here), you'll know that having the right tool for the job is crucial. So, take some time to think about the problem at hand and what tools will help you to solve it. And don't be afraid to learn a new tool or skill - it's like adding a shiny new gadget to your tool belt.

2. Done is better than perfect

We get it, you're a perfectionist. But when it comes to software development, it's important to find that sweet spot between excellence and insanity. Set clear goals and expectations with your customer early on, and don't forget to communicate that software is never truly finished (sorry, it's just the nature of the beast). And if all else fails, remember that a functioning product is better than a perfect one that never sees the light of day.

3. Lower the barrier to entry

Make your product easily accessible to users with minimal effort on their part. Nobody wants to jump through hoops just to use your app. And while videos are great, they're not always the most engaging way to introduce your product. So why not try an interactive joyride? It's like a rollercoaster for your app - fun and exciting!

4. Test early and test often

Testing is like flossing - nobody really wants to do it, but it's crucial to maintaining healthy teeth (or in this case, code). Prioritise testing early in your development process and test every possible outcome (yes, even the weird ones). And while unit tests are great, don't rely on them exclusively - they may not catch everything.

5. User testing

Getting feedback from users is like getting a report card for your product. Set clear expectations and deadlines for user acceptance testing (UAT) and make sure everyone understands the acceptance criteria. And don't forget to involve your developers in the process - they're like your trusty sidekicks, helping you save the day (or in this case, the product).

6. XML schemata

Let's be real, XML schemata can be a bit of a headache. But with a little annotation and default validation, you can save yourself some major migraines down the road. And if you really want to be fancy, why not try some model-driven testing tools? It's like having your own personal XML superhero.

7. Don't mix business logic and database calls

Mixing business logic with database calls violates the principle of separation of concerns, making code less modular and more challenging to maintain. Furthermore, testing such code can be a headache because database interactions aren't easily mocked or isolated. The tests themselves can also be slower and more resource-intensive than those that don't involve database calls. It's a bit like trying to race a car with a full tank of gas and a giant concrete block in the backseat - not the best way to achieve peak performance!

8. Debugging for pros

Keep a clear mind when approaching a problem. Start by checking simple solutions first like configurations, settings, environments, machines, context, and data. Also, consider the ripple effects of the issue on related processes.

9. Coding for production performance

Improve performance proactively based on the expected application use. Review code with performance in mind, watch out for poor scalability, and test for stability and failure points.

10. Raising quality and reducing risk

When it comes to managing a project with the PRINCE2 methodology, you don't want to fly blind. That's why it's crucial to review previous lessons learned before getting started. It's like taking a trip - you wouldn't head out without checking a map or GPS first, right? By looking at past projects, you can identify what worked well and what didn't, giving you a head start on making the most of your project. Plus, by avoiding the same mistakes or inefficiencies that happened before, you'll save yourself a world of trouble (and frustration).

In summary

At WorkingMouse, we believe that sharing knowledge is power. That's why we formed interdisciplinary teams to share insights and lessons learnt. We even have a fancy repository dedicated to storing all of our valuable insights! And we don't just let it collect dust - we periodically revisit and refine our repository at the beginning and end of each project. By doing so, we're committed to staying on top of our game and spreading our knowledge throughout the organisation.

How we empower departments and enterprises



Shannon England

Marketer and coffee lover


Your vision,

our expertise

Book a chat