While looking for a simple deployment platform, I came across WSO2 Developer Platform (formerly Choreo). It is an Internal Developer Platform (IDP) that handles building, deploying, and hosting your applications, allowing you to focus on writing code instead of managing infrastructure.

In this article, I’ll walk you through the complete process of creating an ASP.NET Core Web API, pushing it to GitHub, and deploying it to WSO2 Developer Platform. By the end of this guide, you’ll have your API running in the cloud in just a few simple steps.

Create the ASP.NET Core Web API

For this guide, I’ll assume you already have the .NET SDK installed on your machine and have a basic understanding of developing applications with ASP.NET Core.

To get started, open your terminal and create a new ASP.NET Core Web API project by running the following command:

dotnet new webapi -n DotNetChoreoDemo

This command creates a new ASP.NET Core Web API project named DotNetChoreoDemo.

Next, navigate into the project directory.

cd DotNetChoreoDemo

Before deploying the application, it’s always a good idea to verify that everything works correctly on your local machine.

Although the default project includes Swagger for testing your API, we’ll also add a simple endpoint that we’ll use later to verify the deployment.

Open Program.cs and add the following lines immediately after creating the builder:

var urls = builder.Configuration["ASPNETCORE_URLS"] ?? "http://0.0.0.0:8080";
builder.WebHost.UseUrls(urls);

Next, add the following route before app.Run();.

app.MapGet("/health", () => Results.Ok("OK"));

Now run the application.

dotnet run

Once the application starts, you’ll see the local URL in your terminal.

Open that URL in your browser and navigate to the /health endpoint you created earlier.

If everything is working correctly, you should see the response as “OK”

Push the project to GitHub

Create a public GitHub repository and push your ASP.NET Core project to it.

If you’re using the Free Tier of WSO2 Developer Platform, make sure the repository is public, as the free tier only supports deployments from public GitHub repositories.

Deploying the Application

Open WSO2 Developer Platform by visiting https://console.choreo.dev. If you don’t already have an account, create one and sign in.

After logging in, you’ll land on the Overview page. Click Create Project to create a new project. Once the project has been created, click Create Component.

Since we’re deploying an ASP.NET Core REST API, select the Service component type.

Next, connect the public GitHub repository you created earlier. After selecting the repository, provide a display name for the component and verify the branch and component directory if necessary.

Scroll down to the Build Preset section and select .NET. Choose .NET 8.x as the runtime version, then set the Port to 8080, which matches the port your application is configured to listen on.

Once everything is configured, click Create and Deploy.

The platform will immediately start building your application. Open the Build page from the left sidebar to monitor the progress. Depending on the size of your project, the build may take anywhere from a few seconds to a couple of minutes. Wait until the build status changes to Success.

After the build has completed, open the Deploy page from the left sidebar. You’ll see three deployment stages: Set up, Development, and Production.

From the Set up card, open the dropdown next to Deploy and select Configure & Deploy.

This opens the deployment configuration wizard on the right side.

In Step 1/3 -Environment Configurations, you can add environment variables and secrets such as database connection strings, API keys, or other application configuration.

For this application, click Add a Configuration and create an environment variable named ASPNETCORE_URLS with the value http://0.0.0.0:8080.

This tells ASP.NET Core to listen on port 8080, which is the same port configured for the Service component in WSO2 Developer Platform.

Once you’ve added the environment variable, click Next.

In Step 2/3 -File and Certificate Mount, no additional configuration is required for this application. Click Next to continue.

In Step 3/3 -Endpoint Details, make sure to disable the OAuth2 endpoint authentication by unchecking the enabled option, since this sample API doesn’t require authentication. After that, scroll to the bottom of the panel and click Deploy.

Within a few moments, the Development card should show the deployment status as Active. This indicates that your application has been successfully deployed.

To verify the deployment, click the Endpoints icon in the Development card. This will display the public endpoint URL for your service. Open the endpoint in your browser and append the /health path to the URL.

For example:

https://f2a60d61-0831-4ddf-bb84-4193bdc79cdb-dev.e1-us-east-azure.choreoapis.dev/dotnetchoreodemo/aspdotnet-service/v1.0/health

If everything has been configured correctly, you should receive the OK response from the endpoint, confirming that your ASP.NET Core Web API is running successfully on Developer Platform.

That’s it! You’ve successfully deployed your first ASP.NET Core Web API to WSO2 Developer Platform. From now on, every time you push changes to your GitHub repository, WSO2 Developer Platform can automatically build (make sure to enable auto build from the build section) and deploy the latest version of your application, making it easy to iterate and share your projects.

I wouldn’t recommend using the free tier of WSO2 Developer Platform for a real production application. It’s a great choice for prototypes, demos, personal projects, or testing new ideas. If you’re building an application for real users, it’s better to use a paid plan that is designed to handle production workloads reliably.

Happy building, and let WSO2 Developer Platform handle the rest!

During that time the whole country was closed. Schools were closed, roads were empty, and people stayed inside their homes. Many people remember that time as stressful and difficult, but my experience was a little different.

I live in a village in Kurunegala District(Bamunapotha), so life during the lockdown was quiet and slow. Every day I woke up around 4–5 AM. My alarm was the song “Runaway” by Aurora. In the early morning silence, when that song started playing, I felt completely calm and peaceful

After waking up, I started watching my A/L online class recordings. At that time I was not very active on social media, so most of my day was simple and focused. I still remember watching the Operating System Paging lesson on Pubudu Wijekoon sir’s IT class. I spent time learning, watching lectures, and also learning to build things on the internet.

Once the classes and other tasks were done, I usually listened to the Derana Aruna morning program. They talked about the day’s news and the latest COVID-19 updates in Sri Lanka. I still remember how Army Commander General Shavendra Silva used to join the program during that time to give updates on the COVID-19 situation. That was one of the things I looked forward to as well. Listening to those updates became part of my daily routine during the lockdown.

In front of our house, we have a small coconut land. Sometimes we went there to do a bit of planting vegetables like “nai kochchi”, “karawila” and “bandakka”. It was simple work, but there was something satisfying about spending time on the land and watching things grow.

At the time, I didn’t realize how special those days were. It just felt like normal life. But looking back now, I understand how meaningful and simple those quiet moments.

Today I live in a crowded city for my higher studies. There are vehicles everywhere, constant noise, buildings, and concrete. Life moves fast here, and sometimes it feels uncomfortable compared to the peaceful village mornings I once had. But I know I need to be here for now, to build my future :|

That is why I still remember those lockdown days :)

Maybe I cannot go back to those exact days again. Life always moves forward. But those memories remind me that happiness is often found in the simplest moments.

These days, I am learning Arduino Stuff because we have a group project in the 1st year Fundamentals of Computing module, where we need to build a hardware product.

Our team chose the healthcare category for this project. So, we’re going to collect health insights, like body temperature and heart rate, from the user, transmit the data to an ESP32, and display it on a 16x2 LCD.

However, as a software guy, I feel lonely without adding some software components to this project. So, I suggested to the team that let’s transmit this data into the cloud database and visualize them on a web application.

Now to get into the topic, we need a platform/database to store these data. Generally, I use Supabase as a database for most of my projects, and I decided to use Supabase for this project too. But when it comes to inserting the data into the DB from ESP32, it’s a bit challenging because there is no official library provided by Supabase for that. So after searching on the internet, I saw a cool library called ESPSupabase that connects ESP32/8266 to Supabase via REST API and WebSockets.

So, in this article, I am going to do a simple demo of how to send some mock data from Arduino IDE to ESP32 and transmit that data into the supabase database using ESPSupabase library.

Before start, make sure you have:

· ESP32 Microcontroller
· Arduino IDE
· Supabase Account

Now let’s look at how to make this.

First, go to the Supabase dashboard and create a New project, for this demo I am going to send mock heart rate and body temp data to the database, so in the project go to the table section and create a new table called health_data and add two columns to store the heart rate and body temperature.

Make sure to disable to RLS by clicking the checkbox on the top, because iam not going much deeper in this example.

That is about Supabase. Now let’s go to the Arduino IDE.

I hope you have worked with ESP32 on Arduino IDE before this, if not just follow this video on how to setup ESP32 with Arduino IDE. https://youtu.be/CD8VJl27n94?si=kWZK5QMFF67o9KZH

After setting up ESP32 with Arduino IDE, go to the library manager section search for ESPSupabase, and Click Install.

Now let’s move on to the program.

I’ve added the full code below and explained the code with comments.

Make sure to change the supabase_url , anon_key to your credentials in this code. Also, in the table defining part, add the exact names you used for your table and columns.

You will also need to add your Wi-Fi credentials before uploading the code to the ESP32

// Import WiFi and ESPSupabase Library
#include <WiFi.h>
#include <ESPSupabase.h>

// Add you Wi-Fi credentials
const char* ssid = "YOUR SSID";
const char* password = "YOUR PASSWORD";

// Supabase credentials
const char* supabaseUrl = "YOUR SUPABASE URL";
const char* supabaseKey = "SUPABASE ANON KEY";

Supabase supabase;

void setup() {
  Serial.begin(115200);

  // Connect to Wi-Fi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to Wi-Fi...");
  }
  Serial.println("Wi-Fi connected!");

  // Init Supabase
  supabase.begin(supabaseUrl, supabaseKey);

  // Add the table name here
  String tableName = "healthdata";
  // change the correct columns names you create in your table
  String jsonData = "{\"heartrate\": \"70\", \"bodytemp\": \"37\"}";

  // sending data to supabase
  int response = supabase.insert(tableName, jsonData, false);
  if (response == 200) {
    Serial.println("Data inserted successfully!");
  } else {
    Serial.print("Failed to insert data. HTTP response: ");
    Serial.println(response);
  }
}

void loop() {
}

Next, verify the program by pressing the first blue color icon, and It will successfully compile the program.

Finally, plug your ESP32 into the Laptop/PC and then select to correct PORT from tools > PORT section and upload the program to the board using the second blue color icon.

That’s it! Now, if you go to the Supabase database table, you can see that the mock data we added in this program will be displayed in the columns.

I think now you understand how to easily send data from the ESP32 to the Supabase database

Give it a try, and feel free to expand it with additional features like Row Level Security.

If you would like to learn more about this, please refer to the following documentation.

GitHub - jhagas/ESPSupabase: Connect ESP32/8266 with Supabase. Enhance your IoT project with open-source database service

https://supabase.com/docs