Managing cloud infrastructure should be easy, but if you’ve ever had to manually handle VM snapshots, you know the struggle. Logging into provider dashboards, clicking through menus, double-checking before hitting “delete” (and sometimes still deleting the wrong one)—it’s not exactly efficient.
As someone who values automation, I knew there had to be a better way. So, I built a low-code/no-code application to streamline the process of managing Contabo VM snapshots. Using Appsmith for the frontend, Node-Red as the backend, and custom Node-Red modules to interface with the Contabo API, I created a tool that lets me view, create, delete, and restore snapshots in just a few clicks.
Why did I choose this approach? Open-source tools like Appsmith and Node-Red provide powerful automation capabilities without the complexity of traditional development. Whether you’re a solo developer, a small business owner, or just someone who wants more control over their cloud infrastructure, low-code automation can save time, reduce human error, and eliminate repetitive tasks.
In this post, I’ll walk through how I built this solution, why open source and low-code development are game changers, and how you can leverage these tools for your own automation needs.
Let’s dive in.
Why Open Source and Low-Code?
When it comes to building automation solutions, you have two main options:
- Use a commercial, closed-source tool that locks you into its ecosystem and charges you a monthly fee.
- Leverage open-source, low-code platforms that give you full control and flexibility.
For this project, I chose the second option—and here’s why.
Cost-Effectiveness: Powerful Solutions Without the Price Tag
Many cloud automation tools come with hefty price tags, making them impractical for individuals and small businesses. Open-source software, on the other hand, gives you enterprise-level functionality without the recurring costs. With Appsmith and Node-Red, I was able to build a fully functional automation system without spending a dime on licensing fees.
Flexibility: Adapt the Tools to Your Needs
Commercial tools often impose limitations—whether it’s API restrictions, rigid workflows, or missing features. Open-source platforms like Node-Red allow you to customize every aspect of your automation. If a feature doesn’t exist, you can build it (which is exactly what I did by creating custom Contabo API modules for Node-Red).
Efficiency: Build Complex Automations Without Writing Tons of Code
Traditional development requires writing a backend from scratch, setting up API endpoints, handling authentication, and designing a frontend—all of which take time and effort. Low-code platforms streamline this process.
- With Node-Red, I visually connected API calls, automated workflows, and built a fully functional backend without manually coding everything.
- With Appsmith, I quickly created a frontend that interacts with the backend, allowing for a clean and intuitive UI.
The result? A fully operational snapshot management tool in a fraction of the time it would have taken with traditional development.
Scalability: Start Small, Expand as Needed
Since open-source tools aren’t tied to proprietary ecosystems, they can scale alongside your needs. Today, my app manages Contabo snapshots, but tomorrow, I could extend it to support AWS, DigitalOcean, or any other cloud provider—without being locked into a single vendor’s ecosystem.
Empowering Small Businesses and Non-Developers
Not every business has a dedicated development team, and not every developer wants to spend weeks coding a solution from scratch. Low-code automation bridges this gap. With platforms like Appsmith and Node-Red, even small teams—or solo developers like me—can build powerful tools without needing deep backend expertise.
Bottom Line? Open-source, low-code solutions give you power, flexibility, and cost savings, making them ideal for personal projects and small businesses. Now, let’s dive into the tech stack I used to bring this idea to life.
Tech Stack Overview
Each tool plays a specific role in the system, working together to create a smooth, low-code automation experience. Here’s how they fit together.
Frontend: Appsmith
Why Appsmith?
- Open-source and free to use.
- Drag-and-drop UI builder with built-in REST API and database integrations.
- Rapid development—no need to write a full frontend from scratch.
How Appsmith Works in This Project:
- Displays a list of Contabo VMs and their associated snapshots.
- Provides buttons to create, delete, and restore snapshots.
- Sends API requests to the backend (Node-Red) to execute these actions.
- Gives real-time feedback on snapshot operations.
Essentially, Appsmith acts as the user interface, providing a simple way to interact with the automation running in Node-Red.
Backend: Node-Red
Why Node-Red?
- Visual programming: Build API flows without writing extensive backend code.
- Event-driven architecture: Great for automating workflows and API calls.
- Open-source and highly extensible with custom modules.
How Node-Red Works in This Project:
- Exposes a REST API that Appsmith interacts with.
- Handles requests to list, create, restore, and delete snapshots.
- Sends API calls to Contabo’s API to execute the requested actions.
- Automates snapshot management without the need for a traditional backend.
Node-Red is essentially the brains of the operation, processing user requests and handling interactions with Contabo’s API.
Custom Node-Red Modules for Contabo API
Why Custom Modules?
Contabo provides a REST API, but there isn’t an out-of-the-box Node-Red integration for it. Instead of manually setting up each API request, I created custom Node-Red modules to handle:
- Authentication with Contabo’s API.
- Fetching VM and snapshot details.
- Executing snapshot actions (create, restore, delete).
These modules simplify the process and make it easier to reuse API calls across different Node-Red workflows.
How Everything Connects
- User opens the Appsmith app → sees a list of their Contabo VMs and snapshots.
- User selects an action (e.g., create a snapshot) → Appsmith sends a request to Node-Red.
- Node-Red processes the request → calls the appropriate Contabo API endpoint using custom modules.
- API response is sent back to Appsmith → updates the UI with the new snapshot status.
This setup creates a seamless, automated way to manage VM snapshots with minimal coding effort.
Here’s the next section, keeping it high-level, focused on REST queries, and setting up the benefits of using Node-Red as a wrapper:
Building the Snapshot Management App
With my tech stack in place, the next step was to connect the pieces together—building a simple UI in Appsmith and linking it to my Node-Red backend, which acts as a wrapper for the Contabo API.
Connecting Appsmith to the Backend with REST Queries
Appsmith makes it easy to interact with APIs using built-in REST query support. Instead of writing a full frontend from scratch, I simply:
- Set up API queries in Appsmith to send GET, POST, and DELETE requests.
- Bind these queries to UI components (e.g., buttons for creating or restoring snapshots).
- Display API responses dynamically in tables, text fields, and notifications.
Essentially, Appsmith acts as the interface for my API, allowing me to control everything without manual API calls.
Want to learn more? If you’re new to Appsmith, they provide excellent tutorials and documentation on how to build UI components and connect them to APIs.
Why Not Call Contabo’s API Directly from Appsmith?
Technically, Appsmith could send requests straight to Contabo’s API, but I chose Node-Red as an intermediary for several reasons:
- Abstraction & Simplicity: Node-Red acts as a custom API wrapper, so I can modify how requests are handled without changing Appsmith queries.
- Future Expansion: If I want to add automation (e.g., scheduled snapshots, alerts, multi-cloud support), I can do so in Node-Red without touching the frontend.
- Security & Control: Node-Red can handle authentication, logging, and validation before requests reach Contabo, providing an extra layer of control.
So instead of calling Contabo API endpoints directly, Appsmith interacts with my Node-Red API, which then processes requests and handles the necessary logic. This architecture makes future enhancements much easier.
The Benefits of This Approach
By combining Appsmith, Node-Red, and open-source automation, I’ve created a flexible, scalable, and cost-effective solution for managing Contabo VM snapshots. Here’s why this setup works so well:
Simplified Cloud Management
No need to log into Contabo’s dashboard for snapshot tasks—everything is handled through a custom dashboard that centralizes VM management.
Automation Saves Time
Instead of manually creating or restoring snapshots, I can automate repetitive tasks with one-click actions (or even schedule them in Node-Red).
Future-Proofing with Node-Red as a Middleware
Since Node-Red acts as an API wrapper, I can:
- Integrate multiple cloud providers (AWS, DigitalOcean, etc.) in the future.
- Add custom logic, such as auto-snapshot scheduling or alerts.
- Modify API behavior without changing Appsmith’s queries.
Open-Source, No Vendor Lock-In
Unlike proprietary automation tools, this setup is fully open-source and doesn’t lock me into expensive third-party services. I control the infrastructure and can expand it however I want. Ironically, all the services on hosted on Contabo-hosted VM’s, so if Contabo goes completely south, so does my system.
Empowering Non-Developers with Low-Code
By using low-code tools, even those without deep coding expertise can modify, expand, and maintain the system, making it accessible for small teams or solo developers.
With this approach, I’ve built an automated, scalable, and low-maintenance solution for managing Contabo snapshots—without writing a full backend from scratch.
Next, I’ll share some final thoughts on open-source automation and how this setup can be adapted for different use cases.
Conclusion
Managing cloud infrastructure doesn’t have to be complicated, expensive, or time-consuming. By leveraging open-source, low-code tools like Appsmith and Node-Red, I’ve built an intuitive, automated system for managing Contabo VM snapshots—all without writing a traditional backend or getting locked into proprietary solutions.
This project highlights what’s possible when you combine automation, REST APIs, and open-source technology. Whether you’re a solo developer, a small business owner, or just someone who enjoys automating tedious tasks, this approach proves that you don’t need a massive development team to build scalable, efficient cloud management solutions.
Looking Ahead
This system is just the beginning. With Node-Red acting as a flexible API wrapper, I can:
- Expand support to other cloud providers like AWS, DigitalOcean, or Linode.
- Add smart automation—such as auto-snapshot scheduling, retention policies, or alerting.
- Enhance security and monitoring—logging API actions, setting up webhooks, or integrating authentication layers.
For anyone considering open-source automation, I highly recommend exploring low-code tools like Appsmith and Node-Red. They bridge the gap between coding and automation, making it easier than ever to build powerful solutions without the overhead of traditional development.
If you have questions, feedback, or ideas for improvement, I’d love to hear them! Let’s automate the tedious stuff and make cloud management effortless.