Troubleshooting Unqork Applications


When creating or maintaining applications, you'll inevitably run into unexpected behavior. This is when your software or application does something that you didn't intend it to do. Troubleshooting is the art of mitigating and eliminating these unforeseen behaviors.

Troubleshooting is less straightforward than, "Here are the top ten issues and the precise way to solve them". Troubleshooting is dynamic, and it's an art. Each developer has their own style. The more you develop, configure, tinker, problem-solve, and help others do the same, the better you get at it. You'll start to recognize patterns and relate errors to other errors. Your techniques will expand and evolve.

An opportunistic mindset is one of the most helpful tools in your toolkit. Every error is an opportunity to learn. Also, running into errors is a normal part of software development. Yep, even in Unqork's no-code application platform. 

The goal is to reduce the impact on your end-users. Keep this goal in mind and be patient with yourself. For especially tricky issues, you can always reach out to

Let's go over some guidelines to help you get started.

What You'll Learn

In this article, you'll learn the basic steps of troubleshooting Unqork applications.

Basic Steps of Troubleshooting

Your troubleshooting journey begins when there's an unexpected behavior in your application. This starting point could manifest in different ways. Perhaps you get an error message or discover a problem in a downstream system. Maybe you notice that something displays incorrectly in your application. Whatever the issue is, it's a behavior that differs from how the application should run.

We have some general steps and strategies you can take when troubleshooting. First, we'll cover the basic steps. Then, we'll go over specific strategies. Learning these basics can help as you gain more experience and find your style.

The basic steps of troubleshooting are:

1. Investigate and Replicate. Understand the context of the unexpected behavior and, if possible, recreate the issue.
2. Isolate. Narrow down your search to isolate where the issue lives.
3. Terminate. Now that you know what's causing your issue, you can fix it.

TIP  Use Module Outline to diagnose common issues with configurations. To learn more, visit our Real-Time Configuration Analysis Tool article.

Investigate and Replicate

The first step is to understand the system and what's failing. You'll need to investigate the unexpected behavior before looking for the root cause. This is especially challenging if the person reporting the issue lacks specific details.

Think of the natural progression of what could have led someone to the error. Think of the customer's mindset, and ask yourself how they could have arrived at this issue. Following the flow of the application or module often leads to the page with the error.

More complex errors can seem elusive at times. You'll need to be meticulous and creative. Think of the possibilities that could lead up to the unexpected behavior. This comes down to your understanding of the platform and application. It's important to know what the application should do.

Try different combinations of events and values. Note your results and write down observations. 

Here are some questions you can ask yourself when investigating unexpected behavior:

  • Do I understand the issue?

  • Do I know what's actually happening?

  • What series of events led up to whatever this unexpected result is?

  • Do I understand what's supposed to happen based on the configuration or requirements?

  • What environment is the client in?

  • What role is that person?

  • Are they using test data or production data?

You need to see the failure and understand the context of unexpected behavior. It's a repeatable process that ends in the same behavior over and over again. 

NOTE  Be mindful when replicating a behavior. You should only replicate an error if you can do it without causing issues in production. 

Can you vocalize what the issue is versus how the application should behave? If appropriate, can you replicate the issue? If yes, great. It's time to Isolate the unexpected behavior.


The next step is to narrow down the location of the issue. Some helpful questions to ask yourself are:

  • Can I determine where the behavior is diverging from what's supposed to happen?

  • Where are the two branches starting to break away from each other?

Sometimes, finding the root cause of an issue is like finding a needle in a haystack. One of the best approaches is to divide the haystack in half. Dividing the haystack makes the process more manageable. 

Take your module and divide it in half. Duplicate the module, and remove the second half from the equation. Are you still seeing the error? If so, then you know it's in the current half of your module. If not, you know to check the other half of your module

Once you've narrowed it down to one half of your application, divide it in half again. Continue this process until you've isolated the location of your issue.

Now that you have the location of the issue, you'll isolate individual factors. This is when you check the details of the application's components. If a calculator component does five calculations, look through each calculation.

After you isolate the issue and quickly celebrate, move on to Terminate the issue.

NOTE  The Isolation process can be tedious. Try taking a break or talking out the issue with a teammate. Stepping away for a bit or vocalizing it can help you refocus. 


Now that you know what's causing your issue, you get to fix it. The action could be as simple as a yes instead of a true in a Decisions component. Or, the solution could be a little more complex. If you've investigated and isolated the issue, you've prepared for this step.

Avoid getting too attached when resolving unexpected behavior. Let's say you're troubleshooting a Decisions component. You want the component to deliver specific behavior, and it's not working. Consider whether this component is the best option. Would a Calculator or Initializer be better? Rather than getting tunnel vision, keep an open mind to possible workarounds.

Once you've taken action to fix the problem, take the time to confirm that it's fixed. Make sure that you've taken care of the root cause. Look at the data. Look at the page. Does everything now look the way you expect?

Run the module and repeat the steps from the replication phase. Do variations. Make sure that everything still works. It's good to work quickly, but our main priority is to produce high-quality work.

In the next article, we'll cover some common troubleshooting strategies.