Introduction

Node-RED is an open-source, low-code programming tool developed by IBM. This is licensed under the Apache License 2.0, a permissive open-source license. If you want to know more about software licenses then visit our earlier post Software Licenses: Open Source Vs Proprietary.
In this tutorial we will use Node-RED for API integration with SQL Server database.

Use cases of Node-Red

·        IoT dashboards (collecting sensor data into a database).
·        API integration (connecting REST APIs to SQL Server/NoSQL).
·        Automation workflows (like ETL pipelines, smart home automation).
·        Data processing pipelines (cleaning & transforming data before storage).

Let's begin

First, we will do the prerequisite setup by installing only required softwires before entering into the problem statement example.
In this example we will use any readily available API endpoint which should return sample sensor data in JSON format. We will create Node-Red flow to read the API response, process the data and save into SQL Server database table. Finally, I will attach the flow JSON file for your reference.
Let’s make a start

Prerequisites

·        Install Node.js if not installed already
·        Install Node-RED
·        Run SQL Server
·        Install node MSSQL
Install Node.js
Go to Node.js official site https://nodejs.org/ and download long term support version of Node.js. We will download and install v22.19.0(TLS) for windows

On successful installation use the following command to check the installed 
version of Node.js and npm -v

Install Node-RED
Run the following command to install node-red. The -g flag means installation is global, Node-RED will be installed in your system-wide npm global folder, not in the current directory. Avoid permission issues with --unsafe-perm 

Now install Node-Red node MSSQL by the command npm install node-red-node-mssql
Start the Node-Red
In command prompt type node-red and hit enter to start the Node-Red server. Once the server is running browse the url to lunch the canvas as shown below

I hope we are all set with prerequisites, let’s move for creating the Node-red flow step by step.
STEP:1 Create Inject Node
Inject node the first node in canvas. The Inject node lets you manually or automatically send a message into a flow. Think of it as a trigger. It’s often used to start a flow for testing or to send periodic data. Drag the inject node and keep in canvas as shown in diagram and double click to edit. Keep a name as per your choice. The name I have given is Start.

STEP:2 Create HTTP Request Node
The HTTP request node is used to make HTTP(S) calls (GET, POST, PUT, DELETE, etc.) from your Node-RED flow.It acts like a built-in API client (similar to Postman or curl).You can use it to consume REST APIs or send data to web services.Drag an HTTP Request node, connect it with inject node. Double click to configure.
Method: Get
Url: https://api.thingspeak.com/channels/9/feeds.json?results=5
Returns: a parsed JSON object

Drag a Debug node and connect with HTTP Request node to text the flow so far that we are receiving the API response. Deploy the code and debug to see the data as shown below. If you see data then so far the configuration is correct.

STEP:2 Create Table and Procedure in Database
Create a database or use if any existing database for this example.
Create the following table to store the sensor data received from API endpoint

  Create table SensorData(
  entityId INT,
  light float,
  outsideTemp float,
  timestamp datetime
  ); 
  --Create a procedure to insert data into this table Sensordata as following
  CREATE PROCEDURE sp_InsertSensorData
  @entityId INT,
  @light float,
  @outsideTemp float,
  @timestamp datetime
  AS
  BEGIN
      INSERT INTO SensorData(entityId,light,outsideTemp,timestamp)
      VALUES(@entityId,@light,@outsideTemp,@timestamp);
  END;
  

STEP:3 Function Node to prepare SQL query

The Function node allow us write custom JavaScript code to process, transform, or generate messages in a Node-RED flow.

It is the logic/brain of our workflow. We will create this node to form the SQL query out of API response data to insert into SQL Server database table.
Delete the debug node and drag the function node to the canvas, connect it to the HTTP Request node. Double click to configure.
Name: Prepare SQL Script
Function Code:

  let feeds = msg.payload.feeds || [];
if (feeds.length === 0) {
    node.error("No feeds found in API response", msg);
    return null;
}
//Extract the first feed from the API response
let feed = msg.payload.feeds[0];

//Construct the SQL query for the store procedure
msg.topic =`
    EXEC dbo.sp_InsertSensorData
        @entryId=${feed.entry_id},
        @light=${parseInt(feed.field1)},
        @outsideTemp=${parseInt(feed.field2)},
        @timestamp='${feed.created_at}'
        `;
        return msg;

  

Attach a debug node to test the flow, if all are working fine then result should appear like this

STEP:4 MSSQL Node to execute the procedure & save data into database table

The MSSQL node in Node-RED lets you connect to a Microsoft SQL Server database and run SQL queries or stored procedures.
Drag an MSSQL node, connect it with function node. Double click to configure.
Enter your SQL Server credentials.

Deploy the flow and click on Start button. If your SQL Server connection is active then new record will be successfully inserted into the table.
You can download and import my ready-made Node-RED flow from the attached flow.json

Conclusion:

In this post, we explored how to build an end-to-end data pipeline in Node-RED to consume sensor data from an external API and store it into a SQL Server database. Along the way, we learned about:
Installing and configuring Node-RED.
Using the Inject, HTTP Request, Function, and MSSQL nodes.
Executing stored procedures from Node-RED and verifying data insertion in SQL Server.
 
With this flow, you now have a low-code integration between IoT-style APIs and enterprise-grade databases. Node-RED’s flexibility means you can extend this further — add dashboards, trigger alerts, or connect additional APIs with minimal effort. 
Whether you are working on IoT projects, automation workflows, or enterprise integrations, Node-RED provides a powerful and user-friendly way to connect data from anywhere to anywhere.

Introduction

We need to transfer data from one system to other in the form of events, messages for various reasons. The data can be the real time data, time series data, configuration information etc. Looking into the system requirement we often choose many different ways to deal with this data transformation i.e. REST API based approach, Web socket, MQTT, AMQP etc. In this article we will focus on MQTT vs AMQP. How these two approaches are widely used serving different purposes. What is the basic differences, when to choose which one, and tools available from each type. Let’s get started …

 Introduction

When we build applications in .NET, we often need to run multiple tasks at the same time using threads. But when more than one thread tries to access the same resource (like a file, variable, or database), it can cause confusion or errors if not properly handled. This situation is called a thread synchronization problem.

In .NET, there are several thread synchronization techniques.Lets discuss about Wait and Pulse method from Monitor class.

1.One way signaling

In this problem statement we will deal with one way signaling.

Taking a use case from Building Automation System and its implementation using Monitor.wait and pulse.This is just a simple solution,where in real-time there are better solutions are available looking at the need,which we will take in upcoming posts.

Use case 1

• In a Building Automation System (BAS), an Air Conditioning (AC) controller should automatically respond to temperature changes reported by a sensor.
• The sensor continuously monitors the room temperature.
• If the temperature goes above 26°C, the sensor should signal the AC controller to turn ON the AC.
• If the temperature falls below 23°C, the sensor should signal the AC controller to turn OFF the AC.
• The AC controller should only act when it receives a signal from the sensor, not on its own.

This ensures that the AC runs only when needed, thereby saving power.

Solution

We use the .NET Monitor class for signaling between the Temperature Sensor and the AC Controller.

Step 1 Sensor signals to Controller

• Condition: temperature > 26°C
• Action: Temperature sensor calls Monitor.Pulse to notify the controller.

Step 2 Controller turns AC ON and waits

• Controller wakes up, turns ON the AC, then calls Monitor.Wait to wait for the next signal.

Step 3 Sensor signals to turn OFF

• Condition: temperature < 23°C
• Action: Sensor calls Monitor.Pulse again to notify the controller.

Step 4 Controller turns AC OFF and waits

• Controller wakes up, turns OFF the AC, then calls Monitor.Wait to wait for the next signal.

This one-way signaling ensures the controller acts only when needed, reducing CPU work and saving power.

C# Code sample

using System;
using System.Threading;

class Program
{
    static object locker = new object();
    static bool tooHot = false;  // Shared state
    static bool newSignal = false; // To avoid repeated wake-ups

    static void Main(string[] args)
    {
        Thread sensorThread = new Thread(SensorThread);
        Thread acThread = new Thread(ACControllerThread);

        sensorThread.Start();
        acThread.Start();

        sensorThread.Join();
        acThread.Join();
    }

    static void SensorThread()
    {
        Random rnd = new Random();

        while (true)
        {
            int currentTemp = rnd.Next(20, 30); // simulate sensor readings
            Console.WriteLine($"\n[Sensor] Current Temperature = {currentTemp}°C");

            lock (locker)
            {
                if (currentTemp > 26)
                {
                    tooHot = true;
                    newSignal = true;
                    Console.WriteLine("[Sensor] Too hot! Notify AC controller...");
                    Monitor.Pulse(locker);
                }
                else if (currentTemp < 23)
                {
                    tooHot = false;
                    newSignal = true;
                    Console.WriteLine("[Sensor] Cool enough! Notify AC controller...");
                    Monitor.Pulse(locker);
                }
            }

            Thread.Sleep(2000); // wait before next reading
        }
    }

    static void ACControllerThread()
    {
        bool acOn = false;

        while (true)
        {
            lock (locker)
            {
                while (!newSignal)
                    Monitor.Wait(locker);  // wait until sensor signals

                newSignal = false; // reset after handling

                if (tooHot && !acOn)
                {
                    Console.WriteLine("[AC] Turning ON Air Conditioning!");
                    acOn = true;
                }
                else if (!tooHot && acOn)
                {
                    Console.WriteLine("[AC] Turning OFF Air Conditioning!");
                    acOn = false;
                }
                else
                {
                    Console.WriteLine("[AC] No action needed.");
                }
            }
        }
    }
}

Introduction

Many times, we find ourselves wondering which type of software license would best fit our needs. Without a proper understanding of the various licensing categories, we risk misusing software or even overpaying for tools while similar tools might be available as open source. In today’s post, let’s break down the different types of software licenses and understand how to choose the right one.

What is a software license

A software license is a legal agreement that tells us what we can and cannot do with a piece of software.

It’s like the rulebook the software creator gives us — granting certain rights (like using, installing, or modifying it) and setting restrictions (like not copying it for resale without permission).

In short:

• It protects the creator’s rights under copyright law.
• It defines user rights (use, share, modify, etc.).
• It can be free or paid

Types of software license

There are two primary types of software licenses: Open Source, where the source code is publicly accessible, and Closed Source (Proprietary), where the source code is restricted

While open-source software makes its code or tools publicly accessible, it still comes with certain usage restrictions, which we will discuss further.

1.Open-Source Software License

An Open-Source Software License is a legal agreement that grants users the right to view, use, modify, and share the source code of a software program. Unlike proprietary licenses, open-source licenses encourage transparency, collaboration, and innovation by giving access to the underlying code.

However, open does not mean without rules. Each open-source license comes with its own set of conditions — some are highly permissive, allowing almost unrestricted use, while others require that any modifications or redistributions follow the same licensing terms. This balance enables developers to contribute freely while still protecting their work and upholding community standards. Now open-source software licenses are categorized into two groups; they are permissible license and copy left license. We heard about copy right what is copy left again? Interesting!!!Let’s discuss in detail 😊

Open Source – permissible software license 

These licenses impose minimal restrictions on how the software can be used, modified, or redistributed. They are business-friendly and often allow integration into proprietary products.

Advantages:

• Simple terms, easy to understand.
• Allows both open source and commercial use.
• Encourages wider adoption of the software.
• Compatible with many other license types.

Disadvantages:

• Anyone can take the code, improve it, and release it as closed-source without sharing changes. So, the original authors may not benefit from improvements made by third parties. 

Let’s now explore the different types of permissible software license 

Open Source – permissible software license – MIT License

The MIT License is one of the most permissive open-source licenses available. It imposes minimal restrictions, allowing the software to be used, copied, modified, merged, published, distributed, sublicensed, and sold without limitation.

The only requirement is attribution: the original copyright notice and license text must be included in all copies or substantial portions of the software. This ensures that the original author is credited, even though the license grants broad usage rights.

Due to its simplicity and flexibility, the MIT License is widely used in both open source and commercial projects, and it allows seamless integration into proprietary software.

Open Source – permissible software license – Apache License 2.0

The Apache License 2.0 is a business-friendly open-source license that allows both personal and commercial use while offering strong patent protection. It gives developers flexibility but does not force them to share improvements.

Advantages:

• Allows both open source and commercial use.
• Strong legal protection against patent disputes.
• Flexible — modified versions can have different licenses.
• Encourages adoption by businesses.

Disadvantages:

• Allows proprietary use, so improvements may not be shared back.
• More complex than MIT License, which may require extra legal review.

Are we good to move to the next category of open-source licenses? let’s discuss 

Open Source – Copy Left software license

When we say copy right it means creators has exclusive rights to control how their work is used, copied, modified, or distributed. Without creator's permission, others cannot legally use it.

Copy left is the opposite of copy right, instead of restricting usage, it ensures that the software (and any modified versions) remain free and open for everyone.

In other words, copyleft is a licensing approach that says:

"You can use, modify, and distribute this work freely — but if you share it or make a modified version, you must give others the same freedoms."

This means:

• Any derivative work must be licensed under the same terms.
• You cannot take copyleft software, make improvements, and then release it as proprietary or closed-source.
• I hope we have a good and clear understanding about copy left software license. Now let’s talk about different types of copy left software licenses.

Open Source – Copy Left software license – GNU General Public License (GPL)

The GNU General Public License (GPL) is one of the most widely used copyleft licenses in the open-source world. Its main goal is to ensure that software remains free and open for everyone — not just free in cost, but free in the sense of freedom to use, study, modify, and share.

The key feature of the GPL is its strong copyleft rule:

If a derivative work (modified version) is created or GPL-licensed code is combined with other code, the entire combined work must also be released under the GPL.

This means:

• GPL software can be used, modified, and distributed, including for commercial purposes.
• The source code must be made available when distributing the software.
• The same GPL license must be applied to any modified version so that others receive the same freedoms granted by the original license.
• GPL code cannot be taken, improved, and then released as closed-source or under a more restrictive license.

Example:

If a GPL-licensed text editor is enhanced with new features and then distributed, the source code for that enhanced version must also be shared under the GPL so others can use and modify it.

Why it matters:

The GPL protects the open-source ecosystem by preventing proprietary restrictions from being applied to software that was intended to remain free.

Open Source – Copy Left software license – GNU Affero General Public License (AGPL)

The GNU Affero General Public License (AGPL) is similar to the GPL but with an extra rule for software used over a network. If the software is modified and made available for others to use online (such as in a web app or cloud service), the modified source code must also be shared with those users.

This license is designed to prevent companies from keeping changes private when running open-source software as a service. It is especially important for web-based and cloud applications.

Open Source – Copy Left software license – GNU Lesser General Public License (LGPL)

The GNU Lesser General Public License (LGPL) is a weaker version of the GPL, mainly used for software libraries. It allows the library to be used inside proprietary software without forcing the entire software to be open source.

However, if the LGPL-covered library itself is changed and distributed, those changes must be shared under the same LGPL license. This makes it easier for open-source libraries to be used in both open source and commercial projects.

2.Proprietary (Closed-Source) Software License

This type of license means the software belongs to the company that made it. The person using it only gets permission to use, not ownership.

Key Features:

• Hidden code – The code that makes the software work is secret. It cannot changed.
• Rules for use – The license tells exactly how the software can be used.
• No sharing – It cannot be copied or given to others.
• Mostly paid – Usually needs to be bought or paid for monthly/yearly.
• Updates from company – Only the company can fix problems or add features.
• Company owns it – All rights stay with the maker.

Example: Microsoft Windows, Microsoft Office, Adobe Photoshop

Let’s talk about different types of proprietary licenses.

Perpetual License - Proprietary (Closed-Source) Software License

The software is bought once. After buying, it can be used forever (no expiry date). Ownership of the software is not given (the company still owns it), but the right to use it permanently is given. This is a good license to buy once and use fore ever but there are certation limitations to know before using these types of licenses.

No free major upgrade, need to buy the new version again

Software owner may stop providing security patches after certation period of time. So it may become out dated or insecure over the time.

If someone is agreed to pay gain for new released version or ok to continue without security updates then this license may be a good option to consider.

Subscription License - Proprietary (Closed-Source) Software License

The software is used by paying regularly (monthly, yearly, etc.). The software works only while the subscription is active. Once payment stops, the license ends and the software usually stops working (or switches to a limited/free version).

Example: Microsoft 365, Antivirus software

Trial or Demo License - Proprietary (Closed-Source) Software License

A Trial or Demo License is a temporary license that lets a user try the software for free (or with limited features) for a short time.

It is mainly used by companies to let people test the software before buying.

Concurrent User License - Proprietary (Closed-Source) Software License

A Concurrent User License is designed for organizations where many employees need access to a software, but not all at the same time.

Instead of buying one license per person (which is expensive), the company buys a pool of licenses that can be shared.

The key rule: The number of people using the software at the same time cannot be more than the number of licenses purchased.

Example:

The company buys, for example, 10 concurrent licenses. The software is installed on as many computers as needed (say 100). When a person opens the software, the license server checks availability.  If fewer than 10 people are using it then access is granted. If already 10 are active then the next person must wait. When one person logs out or closes the software, the license is freed and can be used by someone else.

Site/Enterprise License - Proprietary (Closed-Source) Software License

A Site License or Enterprise License is a type of software license that allows all users within an organization (or within a physical location) to use the software without buying individual licenses.

Instead of buying one license per user or per device, the company pays a single organization-wide fee.

Example: A company buys an enterprise license for antivirus software → all employees’ computers are protected.

Conclusion

Understanding software licenses is very important before using or buying any software. Licenses define what can be done, how long the software can be used, and what rights remain with the company. Closed-source licenses such as Perpetual, Subscription, Trial/Demo, Concurrent, and Site/Enterprise each serve different needs — from individuals to large organizations.

Choosing the right license is not just about cost, but also about flexibility, scalability, and legal safety. For personal use, a subscription or perpetual license may be enough, but for businesses, concurrent or enterprise licenses can save money and improve efficiency.

In the end, knowing the differences helps in making smart decisions, avoiding legal risks, and ensuring the best use of software for both individuals and organizations.

What do you think? Which type of license do you use the most, and why? Share your thoughts in the comments below — I’d love to hear your perspective!

Happy reading !