One of the great challenges in the world of modern software development is engineering a piece of technology that anticipates user behaviour or patterns, and can perform effortlessly when faced with an intense volume of requests. At Make IT, we are always looking to work with modern, well-supported technology so that we can meet the requirements of the business while delivering the most valuable experience to the user. This mindset always has us refining our design patterns and processes we use to create these solutions.

The software industry is very dynamic and rapidly evolving, but throughout our engagements we’ve settled on a set of principles that we use to drive the decisions we make about technology selection. This post highlights some of those principles that make up the Make IT Approach.

We use modern web technologies to implement our client applications

The modern web browser is a powerful and convenient way to deliver feature-rich applications.  We use modern web technologies and frameworks such as AngularJS, NGINX, Bootstrap, and Ionic to deliver sophisticated web applications. 

We keep our client and server implementations decoupled

In our applications, communication between our web based clients and the server is handled using a combination of RESTful web services and WebSockets. We do not use any form of server side templating when we build applications. This loose coupling allows us to make changes to either side of the application without impacting the other. This is helpful when adding additional client applications or a public API. It also gives us a great deal of flexibility to decompose and scale our server implementation without impacting the client. Technologies that tie the client and server together require them to stay in lock step and scale only by adding more instances. Our approach gives us a great deal of flexibility in how we deploy and scale a system; and lets us take advantage of the best technology for the job as our applications evolve.

We use technology that is quick to market and maintainable

When selecting languages and tools for our back-end development, we choose languages that are statically typed and supportive of rapid development. There are many toolsets available today that promise a rapid initial implementation by foregoing type safety and leaning heavily on templating engines. We’ve found that while these tools are an effective way to get to market quickly, they suffer greatly in the long run with regard to maintainability and scalability. With the Scala programming language and frameworks from the Lightbend stack, we are able to get a solution to market quickly, without sacrificing maintenance or scalability. This approach is similarly effective in the short term, but in the long-term it saves customers money, creates a better product that can serve as a strong core for future development, and keeps us happy and productive as developers.

We use the right data store for the job

There are a plethora of choices available today for data stores. We’ve found that each of them present unique advantages. and the choice of backing store is entirely dependent upon the needs of each project. We take advantage of SQL and NoSQL stores such as PostgreSQL, Redis, and ElasticSearch in our deployments. Regardless of which store we use, we do always follow a few additional principles. The data store is not a place for business logic, which should always reside at the application server layer. Secondly, our data models should not be tightly coupled throughout the layers of your application. It should be possible to make changes to how data is represented in each layer with minimal impact to other layers in the system, allowing us to react to a product’s evolving needs.

We take full advantage of the power of DevOps

The DevOps tools available today have fundamentally changed how development and deployment is done, for the better. Our solutions always ensure that our environments are reproducible from development through testing and production. Our builds and deployments are all automated, and can be executed with only a single click. We take advantage of cloud providers such as Amazon Web Services to accomplish this, as well as tools such as Docker, Jenkins, Git, Amazon Web Services and Terraform. (Also see the great article by Brian James on DevOps using Dockers.) 

Integrations

Modern solutions integrate with numerous other services, both inside and outside your organization. When approaching these integrations, we ensure that they are abstracted so the system you are integrating with does not drive the domain and design of your application. For example, if you are using a Warehouse Management Platform that we have created for you and are now looking to use a new shipping quote provider (FedEx vs UPS, etc.), we ensure that adding to a new provider of shipping quotes has minimal impact on the core application.

Technology selection

In addition to the items discussed above, we use the following criteria when selecting technology during a typical planning session with a client:

• Open source 
• No licensing costs
• Optional vendor support
• Widely utilized by other organizations already
• Takes into account the future of that technology

By following these principles and choosing the most capable tools that we can, we ensure that we are able to take advantage of new and powerful technologies, without getting stuck supporting technologies that are no longer maintained. If you are looking for a tech partner, here is more on how Make IT approaches ideation, as well as the consultative process. Feel free to comment below or get in touch if you want to discuss these ideas further. We’d be happy to hear from you.