Software development done right – the MdG way
We love working at MdG, because the way we work is the way we think, and feel. Over the years, we shaped our software development process through research and trial and error, trying to maximize the feelings we love, and remove the ones we hate.
Among the feelings we love most: the “thrill of solving” when we get to the bottom of a complex conundrum to achieve perfection and precision; the strive to accept challenges and push to go the extra mile; the joy of removing the unnecessary to find simplicity; the smoothness of turning clunky and convoluted into linear and clear.
Among the feelings we can’t stand: Wasting time in endless meetings; troubleshooting issues when it’s too late; developing something incomplete, or unnecessary.
With experience, we found that the best clients to work with love the same feelings we love, and hate the same feelings we hate. That’s why we put them in the driving seat with us, at every stage: to ensure our clients feel the same feelings as our devs when our product is as brilliant as we all pictured in our minds – and whiteboards!
We are often asked how we manage projects, so here are our golden rules to build something cool while having a great time. This is what you should expect, if you embark in developing a piece of software with us:
1. We (you and us) Co-Design and Co-Develop. For real.
We know how software development goes: You have an idea, we transform it in requirements, we didn’t really get it 100% right, you hadn’t really had it 100% figured out, requirements change, scope change, the project goes over expected time, nobody is happy.
Instead, we want everybody to be happy, so we changed the paradigm, and we include you, the client, in our development team. If you are embarking on a project with us, expect to be part of the team.
First of all, you’ll be on short, to the point, screen-share calls every two weeks. But that’s not enough. You’ll be in the office with us. Modern technology made communication really easy, so that there’s no point to delay deliverables and check-ins.
Collaboration platforms allow us to be in no office and in many offices at the same time. If we are co-designing and co-developing, then this means that you should sit in the same room where we bang our heads on the wall to make our app work exactly as we want.
You’ll be able to see all of our discussions, questions, doubts, real time and will be able to be tagged in questions, so we can remove roadblocks as soon as they appear, not at reviews. No more arguing between client teams and development teams: we are one team.
2. We test our code and take accountability. For real.
Because we hate wasting time troubleshooting issues when it’s too late, we believe in obsessive, precise testing. We test each and every line of our code, using state-of-the-art technologies and international best practices.
Why is this important for us? A well tested code it’s easier to maintain and easier to extend with new features. It allows us to develop stress-free, hedging the risk of unexpected outcomes when the project scales or changes. We learned that developing a software product is rarely like baking a cake following grandma’s recipe. More often, we find ourselves brewing something that evolves and scales with a certain degree of unexpectedness, that needs management. Solid testing is paramount to reduce complexity and make sure we feel comfortable when the unexpected comes up.
Why is this important for our clients? With every release, our client can feel that nice feeling of something that grows from strong foundations. For incremental deliveries to be truly incremental, we all should feel fully comfortable that the next step builds upon and enhance the previous one. Our clients know that when we deliver a piece of code, we take accountability for that product, and for how it works.
This should be a very basic concept and should be given for granted. However, too often this is not what happens in real life, where time and money constraints push devs to deliver fast, taking risks no one should take. This is why we – once again – include client staff in our testing process. If we co-design, we co-test. The key concept is that there’s no black box, where we disappear for a week to test our code and the client doesn’t see visible improvements. The project team caters for testing time upfront, and the value of it is clearly explained and agreed upon, so we can guarantee the highest quality within the required time frame.
As much as possible, we strive to act on a test-driven approach: this means that we write the test cases even before writing the code. The test cases themselves help us – client and devs – to have an overview of the software and how it will work. Once the tests are ready, we start writing the right code for those test cases to be fulfilled.
If you read this far, chances are you are as passionate about shipping good quality innovation as we are: We’d love to hear from you! How do you develop your software? What does software development done right mean for you? Feel free to reach out and let us know what you think of the above, we are always on the lookout for learning opportunities!