ncScale vs Fletch: Best No-Code Monitoring for Xano

Summary

• Fletch is best if you primarily use Xano
• ncScale is best if you use a wide variety of no code tools
• ncScale prioritizes detail and broad integrations
• Fletch prioritizes simplicity and scalability for Xano

Introduction to No-Code Monitoring

The no-code revolution is transforming how we build applications, with platforms like Xano leading the charge in backend infrastructure. But as you scale these tools, you face a new challenge: how to detect downtime in your application i.e. how to implement monitoring and alerting.

Jargon abounds, so let's be clear about what monitoring and alerting means. In simple terms:

• Logging is collecting data from your application about how it's running
• Monitoring is looking for errors, usually by examining logs
• Alerting is sending you a notification when there's an error

Simple enough in theory. But in practice the landscape of monitoring tools is vast and confusing. Tools can be complicated, hard to use, and expensive. If the point of no-code is to simplify development, shouldn't monitoring these systems be straightforward too?

This article aims to cut through the confusion by comparing two popular no-code monitoring options: ncScale and Fletch. It will explain the difference between traditional and no code monitoring tools and how to decide which is right for you.

The Goal of No-Code Monitoring

Monitoring tools can be so feature-rich that it's distracting. Instead of giving you confidence in your application you end up paying for a complicated system that you only use a small piece of.

We need to refocus on monitoring's three main objectives:

1. Detect issues as soon as they occur
2. Diagnose what is causing the issue
3. Respond to issues effectively

Traditional Monitoring Falls Short for No-Code

Traditional monitoring solutions try to accomplish this through logs. Every time a function runs it creates a log that is sent to the monitoring software. Each log is stored, and scanned for anomalies. This is good because you get a lot of information, which means you can get a detailed view of how your application works. But that detail comes with tradeoffs:

1. Cost - each log is processed and stored, and each user can generate hundreds or thousands of logs.
2. False positives - unimportant logs can generate alerts that burn out the team and lead to ineffective responses.
3. Complexity - so much information can make it difficult to find the relevant, actionable root causes of the problem.

Why Xano is Different

When you use Xano, you fundamentally change your monitoring needs. Unlike traditional infrastructure where you manage servers and databases directly, Xano abstracts away these complexities. This means your monitoring approach needs to adapt to this new, simplified environment.

You've abstracted your infrastructure, so it makes sense to abstract your monitoring too. Instead of focusing on low-level metrics and logs, effective no-code monitoring should align with the abstraction level of the platform itself. It should provide insights that are immediately actionable within the context of the no-code environment, facilitating quick problem resolution and performance optimization.

This is where specialized tools like Fletch and ncScale come into play, each offering a different perspective on how best to monitor no-code applications.

ncScale vs Fletch - Foundational Differences

ncScale uses more traditional log-based ingestion, tailored for a no code context. This approach is good if you have many services and need to integrate logs from various sources. It provides a high level of detail and flexibility, allowing you to monitor a diverse ecosystem of no-code tools and services. However, this flexibility comes at the cost of increased complexity and potentially higher expenses as your application scales.

Fletch takes a simpler approach, focused specifically on Xano. Instead of individual logs, it checks your Xano endpoints at intervals to make sure they are healthy, then alerts you if there are business critical errors and helps you escalate to the Xano team to resolve. This approach sacrifices some of the breadth offered by ncScale in favor of simplicity and clarity for Xano users.

Realistic Example

To illustrate the differences between these monitoring approaches, let's consider the same app built with two different stacks: one based on Xano and another using a combination of Airtable, Zapier, and Xano. The app takes data from a CRM, stores it, and then creates APIs for the front end to access the data.

In the first example: we'll use Airtable as the database, Zapier to sync data from the CRM to Airtable, and Xano to create an API. When there's a problem in the database, errors are generated from the API every time it is called. Zapier errors are also generated because it can't reach the database. Assuming you have 1000 users each of which refresh the page once you will get 2000 errors plus additional Zapier errors. Each of them are sent to ncScale which then sends you a notification. Your job is to search through logs from the different services to diagnose the problem. You might see the API errors and contact Xano. They can't help you because the database originating the error. Which then leads you to research solutions for optimizing your Airtable queries.

In the Xano-based scenario, data is stored in a Xano Database, with background jobs to sync data from an external CRM to the database, and APIs to expose the data to the front end. When the database goes down, Fletch detects that the API is returning an error and notifies you. Rather than seeing the logs, you'll see a history of what the API has been returning and when it started to error. You can use this information to immediately create a conversation with Xano support, leading to rapid problem identification (in this case, a database resource issue) and quick resolution through query optimization or resource scaling.

In this scenarios ncScale would bill you for the amount of logs you send to it, while Fletch is always a flat monthly rate.

Conclusion

The choice between ncScale and Fletch ultimately depends on your specific stack and monitoring needs. While ncScale's additional visibility is valuable when using multiple tools, offering a comprehensive view of a diverse no-code ecosystem, Fletch's simplicity excels with Xano-based applications.

If you're primarily using Xano as your backend, Fletch's focused approach can provide a more streamlined, cost-effective monitoring solution that leverages Xano's expertise and integrates seamlessly with the platform. For those working with a variety of no-code tools, ncScale's broader approach might be more suitable, offering the flexibility to monitor and troubleshoot across different services.

Ultimately, your decision should be based on your current stack, future scaling plans, and the level of detail you require in your monitoring. At the end of the day, what matters most is that the tool you use gives you more confidence in your application and reduces your stress.

For advice on implementing an effective monitoring system, contact eric@nocodemonitoring.com