In this blog, I will give you a look behind the scenes on one of our core tools: version control.

Version control is very important for us and our clients, because it makes Keetrax websites and apps faster, more secure, more extensively tested and cheaper to maintain, change and update.

We know that code can look like Greek to the uninitiated. This makes it hard for our clients to see just how we make things happen. You just see the change on your website without seeing the code underneath.

And you don’t need to know code (that’s our job after all!).

But knowing how we manage our code will help you understand why and how a professional workflow will save you money and many headaches.

It is one of those rare gems that makes our developers work more professionally and deliver work at a higher quality, while reducing development time (significantly!).

The gist of using version control is this:

Every change we make to your code is stored as a new “revision” with a description of what the change does. We can view that history, and undo specific changes at any point in the future.


Best explained with a simple example

Imagine this: last week, you requested us to change the “Add To Cart” buttons on your website to read “Add To Cart & Calculate Shipping”.

We made that change in the code, and added it to version control:

Adds 'Calculate Shipping' to Add To Cart buttons
By: Mike Martel
Date: 02 January 2019
Message: Adds 'Calculate Shipping' to Add To Cart buttons, so customers know calc shipping happens in next step.

In the rest of the week we have made dozens of other changes.
But today we added a Shipping Calculator on the product page.

We quickly realize that having a shipping calculator on the product page means that we need to undo our button change! With a press of a button, we can look up what files were touched during this change, and undo this specific change.


It all sounds trivial until you realize what the advantages are! Putting your website or app under version control is a game changer.

Why it rocks

1. Every change is accounted for

Because every individual change is stored independently, including the date and a message including the reason for the change, we know why any change has been made, when it was made and who made it.

This means one developer does not have to remember everything (we have to remember that devs are humans too), but also that other devs can work on your website and know why things are the way they are.

When you ask us why something is the way it is on your website, you will never hear us say “I don’t know”!

2. Rolling back and undoing things is EASY

Websites and apps change all the time, and there are many reasons why things need to be undone.

The big one is when things go wrong: if a change turns out to be broken, you should not have pay for a dev to dig in and figure out which lines of code to remove or undo.

With version control we can press a button and restore your site to where it was before this change.

But also in the normal course of events it makes it easy and quick (in other words: cheap) to remove or roll-back a feature that’s been superseded or that is getting axed.

3. Code Integrity & automated deployments

On every project we work on, we also make sure we have a “one click” way of moving code to the server. This makes live easier for our developers, but also unlocks a quick way of deploying a specific version of the code to a staging site.

That way we can:

  • Test new features away from your LIVE site or application
  • Test new features independently or mix and match them together
  • Quickly revisit an old version of the functionality and design (for reference, or for debugging)

And here is the kicker: this also ensures that ALL the code we wrote for a website, and ONLY the code that’s supposed running the website is online.

You will never see a rogue development feature on your LIVE site, or hear the excuse that we forgot to upload a particular file!

4. No mess (→ better speed and security, and a website that is easier to maintain and extend)

If you read this far, you know it: every past change is stored under version control.

This also means that we can safely delete any code from your website, knowing that we can bring it back within seconds. And we will still be able to do this 3 years down the track.

Without version control, developers don’t have this security.

So what devs without version control tend to do is leave the “code we may need in the future” on the website. They just hide it.

This extra baggage makes your website slower, but also means there is a lot of extra code that could be vulnerable to hackers.

And for developers, all that unused code makes the website much more complicated and harder to maintain. This makes development slower and more error-prone. And that’s where the bills for you start piling up.

5. Team work and collaboration

All the advantages above make it very, very safe for different people to work on your website.

It means that a cheaper junior dev can work on the smaller changes, and that the lead developer can review these independently of what she’s been working on.

Only when everything has been integrated and tested will the lead dev push code to your LIVE site.

At the same time, this system ensures that our junior devs learn from our senior dev, because they can see the reasoning behind every change. This continually reinforces the quality of what we produce!

A real-life example of what version control looks like on our side when developing a Maropost Commerce Cloud (Neto) theme (click for full image).

And that’s only the beginning

There are many more advantages to using version control – I haven’t even touched on the advantages it brings to developers and our own workflow.

We use version control on ALL our code projects, including our Maropost Commerce Cloud (Neto) website development, WooCommerce websites and custom applications. It is one of the main reasons we can promise and deliver Keetrax quality.

If you want more information on this, why not drop us a line?

Leave a Reply