Hacking the game with incremental objectives


Our A to A’ to B philosophy

Most software projects fail because they try to implement too much in just one iteration and end up building the wrong thing. This doesn’t only happen from a technical standpoint, but also from a business point of view. Real life examples are something along the lines of “let’s build a real estate platform” or “let’s build a high performance proxy”.

Such objectives are too vague to tackle in one go. It would be like going from A to B in a single leap. Unless you’re Superman, that won’t work. Think about it this way: when you want to climb a mountain, you start at the bottom, with such and such gear (A) and you want to get to the top (B).

If you want to do it in a single stretch, you won’t be able to (again, unless you’re Superman - got to give the guy his dues). For those of us who aren’t, here’s how we temper this by using our A - A - B philosophy.


Breaking it down


represents your project’s current status or what has been built (your starting point at the base of the mountain), and the project’s tech dependencies (the gear you currently own). B represents the product, the project’s endpoint, which for many people is the IPO (planting your branded flag on the mountain peak for everyone to see).

Instead of trying to jump in and “get things done”, without understanding the impact of the changes, we help you identify what the next step is - A - given your resources (time and money) and the current state of the market. This is the only way to tackle the mountain: one step at a time until you get to the top, making sure you upgrade your gear according to conditions.

A′ is therefore the lean intermediate step that relates to your project, helping it move in the right direction. Just like in math, it’s something related to or derived from A. Its value lies in the fact that it empowers you to: save money, stay on track and keep functionality for ongoing projects. Let’s look at some examples:

1. Save money

Our friends at LoyalSnap wanted to build a dashboard to aggregate certain business metrics for an app with existing users (call it B). Given our intimate understanding of the product and our general tech culture, we were able to advise them to use a tool like Librato (this one’s A′).

This removed the need to write any code apart from the initial integration, therefore cutting the overhead of developing on both back- and front-end. And it also saved our client tons of money in the process. Which, of course, made him really happy:

“Vitamin Software is exceptionally adept not only at working with a client, but anticipating their every need.”

— Gavin Apter, CEO at LoyalSnap, USA


2. Stay on track

Getting A′ right is one of the most important parts of a project, because it allows you to fail fast and pivot, rather than fail later and redo the whole thing. Or think of it this way: making it to the wrong mountain peak, means you need to retrace your steps to get to the right one. Clear milestones along the way would have helped you stick to the right path and make your efforts count.

For example, when we developed a real-estate platform, we had a really tight deadline. We realized we needed to start work on design, implementation and API simultaneously, in order to make it. Instead of rushing headfirst, we started by putting some mechanisms in place to decouple them (A′):

  • A throwaway user interface gave us an idea of functionality for the design and UI part.

  • We created an API simulator tool to assist the UI and API part. We defined the fields that each endpoint needed - inside a Google Spreadsheet - and hooked that up to a Python script that generated JSONs, simulating the behavior of a RESTful API.

This enabled all of them to be developed in parallel (lean), instead of in sequence (waterfall). Obviously it cut down development time tremendously. Moreover, each mechanism provided the team with important data on what and how everything should be implemented. The result was a smoothly developed project:

Vitamin’s team is like a technology creating machine, who understands what you need. They help you understand the product you are developing.

— Alexandru Dan, Veteran Technology Leader, ROMANIA


3. Keep functionality for ongoing projects

In cases where this is possible, our A′ makes sure you have functionality while development of new features is going on in the back-end. FeedProxy’s B was a high performance proxy with a large feature set. This is the perfect example of how to move from one A to the next.

We started out with the functionality (a rough implementation on top of Boost.Asio using a single worker running the io_service) and improved performance with every new A′:

  • Introduced profiling with gdb (GNU debugger) to smooth things out in places where it was sluggish, until we saw diminishing returns.

  • Added more workers to increase throughput.

  • Built the DNS Query Cache, to avoid individual DNS queries, making it faster.

  • Implemented persistent connections, so that the Proxy wouldn’t have to open a new connection for every request.

Each intermediate release was thoroughly load tested using our synthetic traffic generation infrastructure. This is how we ensured it would withstand the real production workload.


Like every step you take up the mountain, once one A is reached it becomes A (your current status) and a new A′ is established and pursued.


Bottom Line

Our A to A′ to B philosophy makes sure projects stay on track. The most important part of it is A′, which represents the milestones necessary to see the project through to end and to develop your product as efficiently and lean as possible. To help you proudly plant your flag on that mountain top.

Because that’s the way we bring value to your project and keep it moving forward.

That’s how we save our clients time and money…

…and that’s how we conquer the internet.