Leveraging Affordable Business Software for Small Business Success

In the digital age, small businesses are constantly seeking ways to streamline operations, enhance productivity, and stay competitive. One of the most effective strategies to achieve these goals is through the smart utilization of software. However, with a plethora of options available, small business owners often find themselves at a crossroads: should they opt for off-the-shelf solutions that are less customizable but more affordable, or should they invest in bespoke software that can be tailored to their exact needs but comes with a higher price tag? In this comprehensive guide, we’ll explore how small businesses can leverage affordable business software to their advantage and when it might be appropriate to consider building custom software.

Understanding Off-the-Shelf Software Solutions

Off-the-shelf software refers to ready-made applications that are designed to cater to a broad audience with common business needs. These solutions are typically cost-effective and can be quickly deployed within your business infrastructure. The primary advantage of off-the-shelf software is its affordability. Small businesses can access a wide range of functionalities without the hefty investment required for custom development.

Moreover, these solutions often come with reliable customer support and regular updates, ensuring that your business stays up-to-date with the latest technological advancements. Examples of such software include accounting packages like QuickBooks, customer relationship management (CRM) systems like Salesforce, and project management tools like Trello.

The Case for Bespoke Software Development

While off-the-shelf software can be a boon for many small businesses, there are scenarios where bespoke software development is the better route. Custom software is developed specifically for your business, taking into account every nuance of your operations, workflows, and unique challenges. This high level of customization means that the software can do exactly what you need it to do, potentially giving you a competitive edge.

Bespoke software can be more expensive and time-consuming to develop, but the long-term benefits can be substantial. It allows for scalability and flexibility as your business grows, and you won’t be paying for unnecessary features that off-the-shelf software might include. Additionally, owning the software means you’re not tied to recurring subscription fees, which can add up over time.

Making the Right Choice for Your Business

Deciding between off-the-shelf and bespoke software is not a one-size-fits-all solution. Small businesses must consider their budget, immediate needs, and long-term goals. If your business requires specialized functionality that cannot be met by existing software, or if you anticipate rapid growth that will necessitate a scalable solution, investing in custom software might be the right decision.

On the other hand, if your needs align with the features provided by off-the-shelf software, and you’re looking for a quick and cost-effective solution, then these readily available applications could be the perfect fit. It’s also worth noting that some off-the-shelf software offers a degree of customization, which can be a middle ground for businesses with specific but not entirely unique needs.

Small businesses have much to gain from the strategic use of software. Whether you choose off-the-shelf solutions for their affordability and convenience or invest in bespoke software for its tailored fit and scalability, the key is to align your software choice with your business objectives. By carefully assessing your needs and resources, you can make an informed decision that will support your business’s growth and efficiency.

Remember, the right software can transform the way you operate, opening doors to new opportunities and enabling you to deliver exceptional value to your customers. Take the time to explore your options, and don’t hesitate to seek expert advice if you’re unsure about the best path forward.

Ready to harness the power of affordable business software for your small business?

Contact Grey Giant Technologies today to explore our range of solutions designed to propel your business to new heights. Whether you're in the market for off-the-shelf software or considering custom development, our team of experts is here to guide you every step of the way. Let's unlock your business's full potential together – get in touch now!

Rescuing Software Projects: A Lifeline for Your Digital Dreams

The Plight of Abandoned Software Projects

In the fast-paced world of technology, the lifecycle of software development can be fraught with unforeseen challenges and obstacles. Startups and established companies alike often embark on ambitious projects, fueled by innovative ideas and the promise of digital transformation. However, the journey from concept to completion is rarely straightforward. Along the way, projects can become stalled or entirely abandoned due to a myriad of reasons: budget constraints, shifting market demands, or the departure of key development team members.

The consequences of a derailed software project are significant. Beyond the immediate financial implications, there’s the loss of potential market share, the erosion of customer trust, and the missed opportunities for growth and innovation. But all is not lost. With the right expertise and approach, these software projects can be rescued, revived, and steered back on course.

The Rescue Operation: Revitalizing Your Software Endeavors

Diagnosing the Dilemma

The first step in any successful rescue mission is a comprehensive diagnosis. This involves a deep dive into the project’s history, examining the initial goals, the progress made, and the stumbling blocks encountered. It’s crucial to identify the root causes of the project’s stagnation. Was it due to technical debt accumulated over time? Perhaps a mismatch between the chosen technologies and the project’s requirements? Or maybe a lack of proper project management and communication channels?

Once the diagnosis is complete, the next phase is to formulate a strategic recovery plan. This plan should address the identified issues with clear, actionable steps. It’s not just about patching up the problems; it’s about setting the project on a new trajectory that aligns with the company’s current objectives and market realities.


Implementing the Turnaround

With a recovery plan in hand, the focus shifts to implementation. This is where the rubber meets the road. The plan must be executed with precision, often requiring a fresh set of eyes and hands. Bringing in a team of experts with a track record of turning around troubled projects can make all the difference. These specialists can infuse new life into the project, applying best practices in software development, project management, and quality assurance.

Key to this phase is the adoption of agile methodologies, which allow for flexibility and rapid iteration. By breaking down the project into manageable sprints and focusing on delivering functional increments, the team can achieve quick wins and build momentum. This approach also facilitates better stakeholder engagement, as they can see tangible progress and provide feedback that can be swiftly incorporated into subsequent iterations.

Future-Proofing Your Project

The final piece of the puzzle is ensuring that the rescued project is not only completed but also sustainable and scalable. This means implementing robust security measures, establishing clear documentation, and setting up a maintenance and support framework. It’s about building a foundation that can support future growth and adaptation, as the software will need to evolve with the changing needs of the business and its users.

The Grey Giant Technologies Advantage

At Grey Giant Technologies, we understand the complexities and challenges of rescuing software projects. Our team of seasoned professionals has the expertise and experience to diagnose, plan, and implement a successful turnaround for your software endeavors. We don’t just aim to get your project across the finish line; we strive to ensure it’s built to last and ready to scale.

If your software project has hit a roadblock, it’s time to take action. Don’t let your vision for digital innovation fade into obscurity. Reach out to us, and let’s work together to breathe new life into your project. With Grey Giant Technologies, your software dreams are in capable hands.

Ready to rescue your software project and turn challenges into triumphs?

Contact Grey Giant Technologies today, and let's chart a course for success.

Crafting a Robust EHR System for Efficient Teletriaging: A Guide

Teletriaging has become an indispensable part of modern healthcare, ensuring patients receive the timely attention and care they need, even during after-hours. For healthcare providers looking to streamline their teletriaging processes, building a custom Electronic Health Records (EHR) system tailored to their specific needs is crucial. In this article, we will delve into the intricate process of developing a ticketing system for an after-hours triage call center, highlighting key considerations such as speed, security, HIPAA compliance, and the potential integration of AI to aid registered nurses (RNs) in triaging more efficiently.

Understanding the Basics of Teletriaging and EHR

Teletriaging involves the use of telecommunication technologies to assess, prioritize, and assign the level of care required for patients based on their medical conditions. A robust EHR system plays a vital role in this process, helping to store, manage, and retrieve patient information swiftly. Before diving into the development process, it’s crucial to understand the unique requirements of a ticketing system for teletriaging, ensuring that the EHR system is equipped to handle after-hours call volumes, categorize cases accurately, and facilitate quick decision-making.

Building the Ticketing System: A Step-by-Step Guide

Step 1: Requirements Gathering and Analysis
Begin by conducting thorough research to understand the specific needs of RNs and other healthcare providers using the system. Engage with end-users to gather insights on required features, workflow preferences, and potential challenges they face during teletriaging.

Step 2: Designing for Speed and Efficiency
Speed is of the essence in teletriaging. Design the user interface to be intuitive, minimizing the number of clicks required to access crucial patient information. Optimize the database for quick data retrieval, ensuring that RNs can make informed decisions promptly.

Step 3: Ensuring Robust Security and HIPAA Compliance
Security cannot be compromised, especially when dealing with sensitive patient data. Implement stringent security protocols, encrypt data at rest and in transit, and conduct regular security audits. Ensure that the system adheres to HIPAA compliance standards, safeguarding patient privacy and confidentiality.

Step 4: Integrating AI to Aid RNs in Triage
Explore the potential of integrating AI algorithms to analyze patient data and provide triage recommendations. This not only speeds up the decision-making process but also enhances the accuracy of triage outcomes, aiding RNs in delivering optimal patient care.

Testing and Quality Assurance

Before rolling out the EHR system, conduct extensive testing to identify and fix any bugs, ensure system stability, and verify that all features function as intended. Focus on load testing to ensure the system can handle peak call volumes during after-hours.

Training and Implementation

Once the system is ready, provide comprehensive training to RNs and other users, ensuring they are well-versed in using the new ticketing system. Focus on change management strategies to facilitate a smooth transition and encourage user adoption.

We can help

Building a custom EHR system for teletriaging is a complex yet rewarding endeavor, enhancing the efficiency of after-hours triage call centers and ultimately improving patient care. By focusing on speed, security, HIPAA compliance, and integrating AI, healthcare providers can develop a robust ticketing system that empowers RNs to triage quickly and accurately.

Are you ready to revolutionize your teletriaging processes with a custom EHR system? Contact Grey Giant Technologies today, and let’s embark on this transformative journey together, crafting tailor-made solutions that meet your unique needs and drive success in your healthcare endeavors.


Hire Programmers that Stick: Mitigate Development Disruptions and Reign Over Your Project

Hiring programmers is an integral part of any software development process. However, the challenge amplifies when you hire a programmer, and they leave the project midway. This disruption can result in delayed deliveries, extensive monetary losses, and an overall sense of chaos.

Programmers that leave

When you hire a programmer, and they depart, the following complications arise:

1. Understanding the Code: Decoding the reasoning behind the code left by the programmer can be excessively complex.

2. Continuity Interruption: The transition from one programmer to another mid-project can cause severe interruptions to the workflow, leading to delays.

3. Timelines Disruption: When you hire a programmer and they vacate the project prematurely, it could cause significant setbacks to the timeline.

Regain Control

Despite these challenges, regaining control of your project is entirely achievable. Here’s what you, as a client, can do:

1. Audit the Project Thoroughly: Ascertain the extent of work done to date, and review the quality of code.

2. Assemble the Right Team: You need to hire programmers with the necessary competence and experience to comprehend and handle the complexities of your project.

3. Set Clear Objectives: Create new timelines, reset the scope, and lay out attainable milestones to ensure you meet your organizational needs.

4. Deploy Effective Project Management: Implement a robust project management system that ensures clear communication, sets firm milestones, and keeps track of the project’s progress.

Hire programmers for the long run

However, looking to hire programmers and manage all these complexities on your own can be a daunting task. In such cases, partnering with a team of experts can be a game-changer.

At Grey Giant Technologies, we are equipped with the industry acuity to help you navigate through these turbulent waters. Whether you need to hire a programmer or a full team, we handle the complexities of your abandoned project and ensure successful completion.

When you choose to hire programmers from us, we guarantee consistency and dedication. We perform a comprehensive project audit and offer a robust project management system to help you keep track of your project’s progress.

Turn the ‘hire programmer’ decision from a trial-and-error process into a well-informed strategy with Grey Giant Technologies. With us, hire programmers who stay committed and get your project back on track with an experienced and reliable partner. Reach out to us today!


Embrace Custom Software Platforms for Business Success

Experience the Advantages of Custom Software Platforms for Business

In our fast-paced digital age, businesses need cutting-edge solutions to stay competitive. Custom platforms offer a powerful way to streamline operations, elevate customer experiences, and foster innovation. Let’s explore how these tailored platforms are shaping the future of business applications and how your organization can benefit.

Precisely Crafted Solutions

Each business has unique needs that off-the-shelf software may not address. Tailor-made platforms are designed from scratch to align with your business goals, providing an ideal fit for your specific requirements.

Effortless Integration

Custom platforms easily merge with your existing systems, minimizing data migration and integration risks. This harmony between business applications enhances efficiency and data accuracy.

Agility and Adaptability

Bespoke platforms can scale and adapt as your business evolves. This allows your organization to stay ahead without investing in entirely new solutions, while staying current with industry standards and technology advancements.

Robust Security

In an era where cybersecurity is paramount, custom software platforms prioritize security from inception. Incorporating the latest protocols and best practices ensures a secure and reliable solution, safeguarding your valuable data and intellectual property.

Custom software platforms give Long-Term Value

Though the initial cost of a custom platform may be higher, the long-term benefits generally outweigh the expense. Custom platforms save on licensing fees, reduce the need for multiple software solutions, and boost efficiency, leading to significant cost savings over time.

Outstanding Customer Experience

Custom solutions enhance user experiences for both employees and customers. Aligning the platform with your organization’s workflows improves productivity and efficiency. Additionally, tailored platforms deliver unique experiences for customers, fostering loyalty and satisfaction.

Custom software platforms are revolutionizing the future of business applications with unrivaled flexibility, scalability, security, and efficiency. By investing in tailored solutions that cater to your organization’s unique needs, you’ll gain a competitive edge and ensure lasting success. Reach out to Grey Giant for a consult to start your custom software journey now!


An Introduction to Dependency Injection in Programming

Dependency injection, or DI, is a programming technique that allows you to manage dependencies between different components of your application. It’s an approach that can help you decouple your code, improve maintainability, and facilitate better testing.

What exactly is DI?

In simple terms, dependency injection involves passing an object to a component, rather than creating that object within the component itself. By doing so, you can manage dependencies more effectively and reduce the coupling between different components of your code.

There are two main types of DI: constructor injection and property injection. Constructor injection involves passing dependencies to a component via its constructor, while property injection involves setting dependencies via properties of the component.

What can DI do?

Dependency injection can help you to write cleaner, more modular code that is easier to test and maintain. It can also make it easier to switch out dependencies and modify the behavior of your application without changing the core code.

One of the best ways to learn more about dependency injection is by reading books and articles on the subject. There are also many online resources available, including tutorials, videos, and forums where you can ask questions and get advice.

What else should I know about DI?

If you’re looking to practice your skills, there are many open source projects and code examples available that use DI. You can also try implementing dependency injection in your own projects to see how it works in practice. If you fancy TypeScript and NodeJS, you can try InversifyJS.

In conclusion, dependency injection is a powerful programming technique that can help you write cleaner, more maintainable code. By decoupling your code and managing dependencies effectively, you can make your applications more flexible and easier to maintain over time.


Regex 101: What It Is, Why It’s Useful, and How to Practice

Regex, short for regular expressions, is a tool that lets you search for patterns in text. It’s used in programming languages like Java, Python, and JavaScript to manipulate and process large amounts of data efficiently. In this article, we’ll explore what regular expressions are, why they’re useful, and where you can go to practice and master this powerful tool.

What is Regex?

Regex is a sequence of characters that defines a pattern to search for in text. You can use it to search for specific characters, words, or patterns in a text file, database, or web page. For example, you could use regular expressions to extract all email addresses from a text file, or to find and replace all instances of a misspelled word in a document.

Why is Regex Useful?

Regex is a powerful tool for processing and manipulating text data because it can search for patterns and extract information quickly and accurately. It’s useful for a wide range of applications, from data validation to web scraping, and can save time and effort when dealing with large amounts of text. Any software developer looking to become a better software engineer should add regular expression understanding to their tool kit.

Where Can I Practice Regex?

To practice using regex, there are many resources available online, including websites like This site lets you enter text and test different regex patterns to see if they match the desired results. You can also find tutorials, cheat sheets, and a regex library on the site to help you learn and practice using regular expressions.

Other resources for learning and practicing regex include online courses, coding challenges, and forums where you can ask questions and get feedback on your code. The key is to find a resource that fits your learning style and provides the level of support you need to become proficient in using regular expressions in your programming projects.


Regex is a powerful tool that allows you to search for patterns in text and extract information quickly and accurately. With resources like and other online tutorials and courses, you can practice and master this tool to become proficient in using it in your programming projects. Whether you’re a beginner or an experienced programmer, learning regular expressions can be a valuable skill to add to your toolkit


Unit Testing 101: The Benefits and Tips to Get You Started

As a developer, you take pride in creating reliable, efficient, and functional software. However, with the complexity of modern software systems, it can be challenging to ensure that your code is error-free and meets all requirements. This is where unit testing comes in. In this article, we’ll explore the benefits of unit testing and provide tips for getting started to help you take your software development skills to the next level.

Benefits of Unit Testing for Software Development

Unit testing is a software testing technique that involves testing individual units or components of code to ensure that they function as intended. The benefits of unit testing include:

  • Providing an extra layer of confidence in your code
  • Catching errors early and preventing them from becoming bigger problems down the line
  • Saving time and money by preventing errors from propagating to other parts of the codebase
  • Identifying areas of code that need to be refactored to make them more modular and maintainable

Tips for Getting Started with Unit Testing

If you’re new to unit testing, getting started can seem daunting. Here are some tips to help you get started:

  1. Start small: Begin by writing tests for small, self-contained units of code, such as individual functions or methods. This will help you get comfortable with the process and build up your testing skills.

  2. Use a testing framework: Use testing frameworks like JUnit for Java and Pytest for Python to provide a structured way to write and run tests, making the process easier and more efficient.

  3. Write testable code: When writing code, think about how it will be tested. Make sure your code is modular and loosely coupled, so that individual units can be tested in isolation.

  4. Use automation: Automated testing tools like Jenkins and Travis CI can help you automate the testing process and catch errors early. This can save time and provide an extra layer of confidence in your code.

  5. Refactor as needed: As you write tests, you may find areas of your code that are difficult to test or maintain. Use this feedback to refactor your code and make it more modular and testable.


Unit testing is a powerful technique for ensuring that your code is reliable, efficient, and functional. By writing tests for each unit of code, you can catch errors early, save time and money, and build extra confidence in your code. With these tips, you can get started with unit testing and take your software development skills to the next level. Start small, use a testing framework, write testable code, automate, and refactor as needed to improve the quality of your software.


4 Ways to integrate the AirTable API

Working with the AirTable API

Learn more about AirTable integration possibilities and how Grey Giant can help you solve your AirTable API needs.

1. Using AirTable Extensions

Whether you have an inventory management system, a custom CRM or another AirTable use-case, there are plenty of pre-built AirTable Extensions on the AirTable Extension Marketplace. AirTable themselves as well as other AirTable developers have created a handful of tools and services to help you stretch your AirTable Bases just a bit further to help your business’ custom needs.

Using the AirTable’s extension system is very straightforward and easy to set up. Simply find the AirTable extension, install it, and walk through the setup built by the developer. You can have anything from Marketing Integrations tools, third-party service integrations or some more simple visualization and data transformation tools. Additionally, AirTable offers “custom scripts” as an extension. This is a piece of code that can be written to integrate with third party systems, other tables or bases and be built to your exact needs.

2. Using AirTable Automations

A personal favorite of the Grey Giant team, AirTable’s automations are an extremely useful tool. With AirTable automations you are able to update other records, tables or even bases with automations. Like extensions, automations have extensive use. However, AirTable’s automation system is event driven. This means when records are updated or added, AirTable is able to send an event to be processed.

AirTable’s extension library does have some extensions useful for the automations’ functionality. However, our favorite part of automations is being able to integrate custom scripts. These scripts when coupled with Cloud Services provide a robust and highly customizable business information flow that is unique to your business and needs.

3. Using the AirTable API

If you need a completely custom setup and services you can’t find out of the box with AirTable Extensions or automations, the AirTable API might be something your business investigates. Like Extensions and Automations, the AirTable API can interact with your custom bases, tables and records. However, unlike the two provided AirTable services, this functionality can, and most likely will happen completely outside the AirTable Ecosystem.

Use cases for the AirTable API may include systems that process information outside of AirTable, but the final result should be recorded inside your AirTable base. For example, maybe you have a QuickBooks integration that processes your inventory and eventually will send high level counts to your AirTable base. The system would do its calculations and measurements in your integration tool, and then eventually push over the insights and highlights to your AirTable bases.

4. Using AirTable Webooks

Another useful integration methodology would be to use Webhooks. Webhooks are useful when you need to send information from AirTable to your third-party services.

Most webhooks use cases are highly complex and custom. While Grey Giant is capable of doing work revolving webhooks, we have found that most of the integrations we’ve faced have been built, and utilized through AirTable Extensions, Automations or the API. There are rare use cases for it that might involve a lot more data transformation before it can be used by your third party service.

Note: Webhooks are only available to enterprise accounts. So you won’t be able to use these on free or lower-tier paid accounts.

A Cloud based use case with AirTable Automations

We’ve recently integrated AirTable with a custom application. In essence, the client wanted to aggregate all the platform data in an easy-to-use data warehouse. We chose AirTable as the final location of the data, because it allows for non-developers to easily built views, charts and reports on all their platform data.

We used the AirTable automations & Extensions tools to create custom scripts that sent over event data to Amazon Web Services Cloud tools. These custom Cloud Services transformed and processed the data from their application and pushed over the data on a weekly basis to their AirTable bases. 

The client was very pleased with the data and how their team was able to create all different sorts of slices of data of their information. From account views all the way down to grouping users by certain properties and knowing the data was up-to-date and gave them real insight into their active userbase.

Experienced AirTable Extension, Automation and WebHook Development

Grey Giant Technologies has worked with AirTable extensions, AirTable API and automations frequently. Integrating data into different services is a strong service that we offer, and we work diligently and thoroughly to make sure we understand your data and it’s purposes before starting any integration.

Before plunging into the freelancing world or hiring a one-off contractor to integrate your custom services and vendor APIs, consider Grey Giant Technologies for your next integration needs.

If you’d like to learn more, contact us and set up a time to chat!

Need some guidance on your AirTable Integrations?

Let's get in touch!

Strong TDD strategies that really help prevent bugs

There isn’t much that compares to the feeling of deploying your latest changes to production and finding out the features don’t work. A good TDD strategy can help prevent the stress and anxiety of production level bugs.

These scenarios will be a rite-of-passage if you ever find yourself in such predicaments. Early in my career as a fresh bright-eyed software developer, I was on production updating a platform and I brought the system down for 10 minutes. This is an experience I’ll never forget and helped me become a better software engineer.

I don’t want to blame it entirely on the company I was working for, but they had no concept of TDD or Test Driven Development. Worse yet, they had little to no test coverage in general. If it wasn’t me that was going to make that mistake, it was another developer.

"Checking Out" TDD

You may do some research and find that Kent Beck is attributed to what we now know as TDD. However, with a bit more digging you’ll see that designing software with tests has been around since the beginning of software development. Back then author Daniel McCracken was making a case for “Checking Out” his software while writing it.

In its most simple form Test Driven Development is writing tests before or during development of the software. Daniel McCracken writes in his book that “In order to fully ascertain the accuracy of the answers, it is necessary to have a hand-calculated check case with which to compare the answers which will later be calculated by the machine.” In short: Write test cases to prove the code works.

Test Driven Development strategies will include several types of testing. I’ll be covering the basic pillars of testing your software. These pillars include unit tests, integration tests, and end-to-end testing.

There are many types of testing and they can all be mixed and matched to create a solid TDD strategy.


Unit Tests and TDD

A key ingredient to a good TDD strategy is to test as granular as possible. Unit tests do just that. When correctly tested, you can be confident that every unit or method in your class or function set is working as intended.

A fruity example

Let’s take a fake ordering platform “Fruit Stand.” Fruit Stand allows end users to purchase fruit from an app on their phone. The following unit test will ensure that the getTotal function is working on the Order class.

Note: All the following is pseudo-code and should not be copy-pasted.

let fruit = new Fruit(2.99); // Accepts price in constructor
let order = new Order();

let out = order.getTotal(fruit,20);

Let's take a peek into how getTotal is defined.

class Order {
details: string;
getTotal(fruit: Fruit, qty: number) {
return fruit.getPrice() * qty;
setDetails(details: string) {
this.details = details;
getDetails() {
return details;

You’ll see that we pass in the Fruit class as an argument. This tactic is known as dependency injection and helps our software become more testable.


Creating the test

Our unit test will test the single function getTotal. In the test, we’ll create a new mock Fruit, pass it and a quantity variable to an instantiated Order, and run assertions.

In order to write a test for this at the unit level we will want to create a Fruit “double” or mock class. This is because getPrice is used in the getTotal function of the Order class. The true functionality of getPrice is outside the scope of this unit test.

class MockFruit extends Fruit{
getPrice() {
return 1;

There are numerous testing frameworks out there to help you setup mock objects, test doubles, fakes and spies – but that’s beyond the scope of this article. Simply put, the above mock is a way to create a test double, but not necessarily the best way.

Asserting the unit test

Since our mock object returns 1 as the price, we can expect the quantity to be equal to the return value of getTotal. Additionally, we’ll want ensure that the getPrice function was in fact called on the Fruit class.

test(“Test Order getTotal”, () => {
const fruit = new MockFruit()
// We want to be able to determine getPrice was called
const spy = spy(fruit);
const order = new Order();
const orderTotal = order.getTotal(fruit,20);

// Assert total to return proper price
// Assert getPrice to return proper price

With the test above, we can be sure of two things:
1) The getTotal is returning the correct price
2) The getPrice function is firing correctly from getTotal

Unit tests are small in scope and should make sure or assert that certain conditions are true on a granular level. You’ll notice our tests don’t validate whether or not the getPrice function is working as intended. This is because it needs its own unit test. A good TDD strategy will have a large number of unit tests. This will ensure things are working on the smallest level and will reduce bugs in production.

TDD and Integration Tests

Testing many functions or class methods together is known as Integration Testing. The integration test should be relatively small in scope and cover only a handful of functions.

A simple example

Taking our fruity example we can build an integration test to ensure the Fruit, and the Order classes work together in tandem. Let’s see how the two are defined:

// Fruit.*
class Fruit {
name: string;
price: number;
getPrice() {
return this.price;

// Order.*
class Order {
details: string;
getTotal(fruit: Fruit, qty: number) {
return fruit.getPrice() * qty;
setDetails(details: string) {
this.details = details;
getDetails() {
return details;

When we Unit Tested Order our TDD strategy was to test the individual function getTotal. Let’s test that same function, but in an integration test.

test("Test Fruit & Order Integration", () => {
const fruit = new Fruit(10)
const order = new Order();
const orderTotal = order.getTotal(fruit,20);

// Assert total to return proper price

It may seem kind of strange to test the getTotal function again in an integration test, but this test allows us to assert the following.
1) The function orderTotal is returning the correct total using a non-mock Fruit object
2) The Fruit object is correctly returning it’s price in the context of this integration
3) Order is correctly calculating the total using a non-mock Fruit object

Are integration tests redundant?

Yes and no. They do test single units but mainly focus on their integrations with other functions or classes. It may feel redundant, but true redundancy in testing is hard to achieve – unless of course you write the same exact test twice.

Complex Systems require good integration tests

In this rudimentary example it seems kind of silly to do this kind of testing. But if we continue developing this application and end up changing how the method getPrice works, we’ll want to be absolutely positive that it still works as expected with other parts of the code. Changes in complex systems require our new code to work as expected with previous tests. Integration test failures will rear their head in regression testing and we’ll know if they work or not.

Integration Tests should be built anytime you connect two or more of your components together in the system. If you have many components working together, it may be worth writing several integration tests for the same sequence using mocks or doubles. However, the mocks or doubles should be never add doubt to the integration test.

Include End-to-End testing in your TDD Strategy

End-to-End testing is a strategy that tests your application from the UI/UX level all the way down to the datastore layer. There’s a couple of technologies that I’ve used that come to mind, like Cypress and Selenium. Cypress markets itself as an end-to-end testing platform and synergizes beautifully with Jest and other assertion technology. Selenium, on the other hand, promotes itself strictly as browser automation. Both are designed for web applications and meant to run the browser automatically.

Automated End-To-End Testing will save tons of time.

Another method is clicking through defined sets of sequences and protocols by hand to provide manual end-to-end testing. However, this is an arduous and time consuming task. A proper TDD strategy will take advantage of automation technologies to implement end-to-end testing procedures that mitigate production bugs.

Automated testing works just like any other testing. Each framework is a bit different, but at the end of the day you run a set of actions and then assert bits of data and expectations that the platform should have.

For example, when I am writing Cypress tests, I like to intercept the API calls and assert that the data is as expected. Additionally, I like to assert that certain DOMs contain the correct data and read correctly.

Implementing End-To-End technologies in a TDD strategy will increase your confidence in your code and application. You can rest better knowing the end-user’s experience has been tested and is working as intended.

A strong TDD strategy

Having a good TDD strategy will make you feel more confident about releasing code.

Making new changes, updates or large scale features will seem less daunting. This is because you know that you have the means to check the many corners and dark recesses of your code.

There is a double-edged sword aspect to testing. Test Suites can become too large. These large test suites take time and resources to run. You may have automatic testing through a CI/CD pipeline or you simply press “Run Tests” on your dev machine and make a cup of coffee. Either way, resources need to be used to perform these tests.

There is a concept called selective testing that may come in handy. It is the idea to run segmented test suites instead of the platform’s entire test base.

In this writer’s opinion having too many tests is a good problem to have; having too few tests is a bad problem to have.

Developing a good TDD strategy will include unit tests, integration tests, and end-to-end testing. These methodologies will increase your confidence in your code, prevent bugs in production, and overall just make the developing experience much more sane.

Do you need help employing TDD or other testing strategies?

Reach out and let us know!