One advantage of StellarDS is the low initial setup effort. After registering and logging into the web dashboard, a new project can be created. There, users immediately receive an overview of key metrics (number of requests, tables, users, etc.) as well as the ProjectID – a unique identifier required for API calls.

In the dashboard (Figure 1), new tables can be defined. In the Tables section, StellarDS lists all database tables of the project. 

Figure 1: The Dashboad of StellarDS.

A click on Create New Table allows the entry of a table name and description. Via the Manage button, users are taken to the detailed view of the table, which provides the following actions:

• Create fields: Under Fields, new columns can be defined via Add Field, including data type e.g., String, Integer, Booleanand optional size limitation. StellarDS is based on a relational schema. Each field has a defined type and optional constraints, such as length for strings. Primary keys (ID) are automatically generated as auto-increment fields, so no manual ID assignment is required.
• Manage permissions: Under Permissions, it can be configured which roles are allowed to perform which actions on the table. Various roles e.g., Admin, User, etc. are defined via the dashboard, and permissions such as read, write, or delete can be assigned.
• View data: Under Menu Data, the dashboard displays the table contents. During development, it is useful to be able to manually inspect or add records.

 

Figure 2: Configuration of roles and permissions in dashboard.

All necessary administration tasks can be performed in this way via the web dashboard.

For authentication, StellarDS offers two options: access token and OAuth2. An access token is stored in the dashboard and is then initially used for API calls or when using the SDK. However, this token should only be used in non-public clients e.g., server code, since it does not provide precise user control. For mobile apps or web apps, the OAuth2 flow is intended: an OAuth application is registered in the dashboard with a redirect URL, and the OAuth code exchange is then used to obtain access and refresh tokens. StellarDS supports OAuth 2.0 and thus complies with modern security standards.

An important feature is support for multi-tenancy. When multi-tenancy is enabled, data is automatically separated by user, i.e., user A sees only their own records, and user B only theirs, even though both use the same table structure. This is handled in the background by the role and permission system. Alternatively, multi-tenancy can be set up at the project level.

REST-API and SDKs

In addition to the web interface, StellarDS provides a comprehensive REST-/JSON-API, so that all the steps mentioned (creating tables and fields, assigning roles, writing/ reading data) can also be performed automatically or from custom tools. To communicate from application code, Software Development Kits (SDKs) are available for Delphi, Python, JavaScript (TypeScript), and C# (.NET). These libraries abstract the REST endpoints and enable access to the cloud backend with just a few lines of code. This makes backend integration very straightforward. It is sufficient to install the corresponding StellarDS SDK in the project, store an access key (access token), and then data can be created or retrieved in the cloud.

Well-calculable and transparent cost structure

The use of a backend service can in many cases offer advantages in terms of cost. There are a free tier and several monthly package levels, each with clearly defined scope (https://stellards.io/#pricing). This makes it possible to calculate costs precisely. In contrast, usage-based cloud models (pay-as-you-go) carry the risk of unpredictable expenses. Fixed prices provide planning reliability and enable greater budget adherence compared to variable models.

The economic advantage of the BaaS (Figure 3) approach also becomes evident when compared to IaaS/ PaaS or self-hosting. Operating own servers requires not only infrastructure but also considerable personnel effort: installation, maintenance, and scaling often tie up entire teams and generate high costs. Additional measures for high availability further increase the effort. With a BaaS solution, many of these indirect costs are eliminated, since operation, updates, and scaling are handled by the provider. New projects can thus be set up in hours instead of months. The significantly shorter time-to-market saves resources and enables an earlier market entry.

 

Figure 3: BaaS compared to other cloud services.

In traditional environments, there are also hidden costs: fees for data traffic, storage, or computing power increase with growing usage and can lead to additional expenses. On top of that comes administrative overhead for updates and monitoring as well as expenditure for fault tolerance, all of which must be factored in.

StellarDS addresses these risks. Once the quota is exhausted e.g., maximum requests per month, no higher costs are incurred automatically. Instead, users can decide to upgrade to the next plan. This principle prevents surprises and ensures cost control.

Data modeling through relational table structure

StellarDS uses tables with defined fields, like a traditional SQL database.

• Tables and fields: Each table can have a set of fields with specific data types. Common types such as strings, integers, floating-point numbers, boolean values, as well as date and time formats are supported.
• Relational links: A major advantage of the table model is the ability to represent relationships between tables. StellarDS provides join queries that allow data to be queried across table boundaries. In a multi-table application, for example, there may be an Orders table linked to a Customers table via a foreign key – and with a join, orders can be combined with customer data in a single query. This feature also enables more complex relational queries.
• Flexible query options: In addition to joins, the API also supports filters, projections, and sorting to selectively retrieve data. For example, WHERE queries can be used for filter conditions, and SELECT queries for column selection.
• In summary: The backend schema can be modeled in a similar way to a relational database, which enables a structured approach, especially for more complex applications.
  
  

Easy integration into projects with JavaScript, Python, Delphi, and .NET

• The REST API can be accessed from any language or platform and be used with the official SDK libraries.
  
  

JavaScript / TypeScript

For JavaScript, there is an SDK library available as an npm-package (also suitable for TypeScript). It provides classes such as TableService, which offer methods for working with tables and records. It is installed via:

npm install stellards_typescript_sdk 

and then the required services are imported. In the example, we initialize the TableService with our project token (access token) and the ProjectID, and then perform read and write operations:

import { TableService } from "stellards_typescript_sdk";
// Initialization of the service with authentication and project
const tableService = new TableService("ACCESS_TOKEN", "PROJECT_ID");
// 1. Retrieve all records from a table (e.g., table with ID 100)
const response = await tableService.getTableData("PROJECT_ID", 100);
if (response.isSuccess) {
  console.log(`Records found: ${response.data.length}`);
  for (const record of response.data) {
    console.log(record.id, record.Name, record.YearOfBirth);
  }
}
// 2. Insert a new record into the table
const newRecord = { Name: "Alice", YearOfBirth: 1990, Married: false };
const addResp = await tableService.addRecords("PROJECT_ID", 100, [newRecord]);
if (addResp.isSuccess) {
  const created = addResp.data[0];
  console.log(`Created record with ID ${created.id} for ${created.Name}`);

• Explanation: First, we create a TableService and pass in our auth token and the ProjectID. This ensures that all subsequent method calls are authenticated. With getTableData(proj, table) we retrieve all entries of the specified table. The returned response contains a field data, which represents an array of records as objects, as well as isSuccess and, if applicable, messages. In the loop, we log the ID, Name, and YearOfBirth of each record as an example. Next, we create a new object newRecord with the appropriate fields and use addRecords(proj, table, [record]) to add it. The API allows multiple records to be added in a single call. In addResp, we again see isSuccess and, in case of success, data with an array of the inserted entries. We output the newly generated ID to verify that it worked.
  
  

Python

Installation is done via pip:

pip install StellarDS

The SDK encapsulates the API in a StellarDS class with submodules for table, field, data, etc., to manage tables and data. We demonstrate access by reading all entries and creating a new record:

from StellarDS import StellarDS
# Initialization with access token (OAuth2 flow would also be possible)
ds = StellarDS(is_oauth=False)
ds.access_token("ACCESS_TOKEN")  # Set token
# 1. Retrieve records from a table
response = ds.data.get(PROJECT_ID, TABLE_ID)
if response.status_code == 200 and response.is_success:
    print(f"Records found: {len(response.data)}")
    for rec in response.data:
        print(rec.id, rec.Name, rec.YearOfBirth)
else:
    print("Error fetching data:", response.messages)
# 2. Add a new record
new_record = { "Name": "Alice", "YearOfBirth": 1990, "Married": False }
add_resp = ds.data.add(PROJECT_ID, TABLE_ID, new_record)
if add_resp.status_code == 201 and add_resp.is_success:
    created = add_resp.data[0]
    print(f"Created record with ID {created.id} for {created.Name}")
else:
    print("Error adding record:", add_resp.messages)

• Explanation: We create a StellarDS object and configure it for access token usage (is_oauth=False). The token is set via ds.access_token(...). We then use ds.data.get(proj, table) to read the table. The response is checked for HTTP status 200, and we then iterate over response.data. Using the Python SDK, the JSON records are converted into objects whose fields can be accessed as attributes e.g., rec.Name. Next, we add a new record with ds.data.add(proj, table, record). If the operation is successful (HTTP 201 Created), add_resp.data contains a list of the inserted records. We output the ID and the name of the first element to confirm success. The Python library also encapsulates the creation of tables and fields and supports the OAuth login process.
  
  

Delphi (Object Pascal)

There is, on the one hand, a TMS WEB Core component for StellarDS for web-based Delphi apps, and the TMS FNC Cloud Pack for VCL/ FMX. Access is often asynchronous here, using events. Our example shows how to load and generate records:

uses
  SysUtils, Classes, TMSFNCCloudStellarDS;
var
  Stellar: TTMSFNCCloudStellarDS;
  Records: TTMSFNCCloudStellarDSDataResult;
  Rec: TTMSFNCStellarDSDataItem;
begin
  Stellar := TTMSFNCCloudStellarDS.Create(nil);
  try
    // Set access token for authentication
    Stellar.Authentication.AccessToken := 'ACCESS_TOKEN';
    Stellar.ProjectID := 'PROJECT_ID';
    // 1. Retrieve records (synchronous call, alternatively via events)
    Records := Stellar.GetRecords(TABLE_ID);
    if Records.IsSuccess then
    begin
      Writeln(Format('Records found: %d', [Records.Data.Count]));
      for Rec in Records.Data do
        Writeln(Rec.Values['Name'] + ' (' + Rec.Values['YearOfBirth'] + ')');
    end;
    // 2. Insert a new record
    if Stellar.AddRecord(TABLE_ID, '{"Name": "Alice", "YearOfBirth": 1990, "Married": false}') then
      Writeln('Record added successfully');
  finally
  end;
end;

• Explanation: At runtime, we create a TTMSFNCCloudStellarDS object. Next, an access token previously generated in the StellarDS dashboard is set, and the ProjectID is assigned – these properties ensure that all API calls are authenticated and addressed to the correct project. With GetRecords(TableID) we request the records of the specified table from the service. The method returns a result object containing the data. We iterate through the list and output the Name and YearOfBirth. Afterwards, we add a new record using AddRecord. If successful, AddRecord returns true. Many methods can also be used asynchronously, i.e., one could call Stellar.GetRecords and process the result in an event handler, which avoids UI blocking. To understanding SDK usage, we have used the synchronous variant here.

.NET (C#)

For .NET, a NuGet package is available (Stellards.SDK), which can be used cross-platform, i.e., in ASP.NET (Web), WinForms/ WPF (Desktop), MAUI (Cross Platform), and Blazor (Web, SPA). This SDK provides strongly typed client classes that encapsulate API access. The following C# example demonstrates the use of the Data API for reading and writing records:

using StellarDs.SDK.Api;
using StellarDs.SDK.Client;
using StellarDs.SDK.Model;  // contains definitions such as CreateRecordRequest
// API configuration with access key
var config = new Configuration();
config.AddApiKey("Authorization", "YOUR_ACCESS_TOKEN");
config.AddApiKeyPrefix("Authorization", "Bearer");
var dataApi = new DataApi(config);
// 1. Read records from table
try {
    var projectId = "PROJECT_ID";    // as string/Guid
    var tableId = 100L;              // table as numeric ID
    // GET query, optionally with filter/sort parameters
    AbstractObjectQueryResult result = dataApi.Get(projectId, tableId);
    if (result.IsSuccess) {
        Console.WriteLine($"Records found: {result.Count}");
        foreach (var obj in result.Data) {
            // obj is of type AbstractObject (dynamic structure)
            Console.WriteLine(obj["Name"] + " (" + obj["YearOfBirth"] + ")");
        }
    }
}
catch (ApiException e) {
    Console.WriteLine("Error in DataApi.Get: " + e.Message);
}
// 2. Insert a new record
var newRecord = new Dictionary<string, object> {
    {"Name", "Alice"}, {"YearOfBirth", 1990}, {"Married", false}
};

• Explanation: First, we configure the API client by creating a Configuration container and setting the Authorization header with our access token (including the prefix "Bearer" according to the OAuth2 standard).
• We then instantiate DataApi. This class provides methods for the data endpoints. For read access, we use Get(projectId, tableId, ...). In our simple case, we retrieve all records of a table. The response AbstractObjectQueryResult contains, among other things, Data (a list of results) and Count. Since the exact structure of the records is not known at compile time (they are dynamic tables), the records are returned as a generic structure of type AbstractObject. We output the Name and YearOfBirth.
• Write access is done via Post(projectId, tableId, createRecordRequest). For this, we create a CreateRecordRequest object to which we pass a list of records (in this case, a single one). After the call, we check whether addResult.IsSuccess is true and then read the assigned id from the first returned record.
• In particular, the integration into various .NET application types makes the use of the SDK very flexible.
  
  

Conclusion

StellarDS presents itself as a developer-friendly Backend-as-a-Service that stands out for its ease of use and clear data model. Developers appreciate the structured relational tables, as they allow clean modeling and powerful query options (filters, joins, sorting). Using a backend reduces work in many areas, such as server and database maintenance, scaling, and security implementation. The learning curve is shallow. With the web dashboard and SDKs, a cloud datastore can be integrated into an application within a short time. The cost structure is transparent and predictable.

Sources

https://stellards.io

Written by Veikko Krypczyk · Reviewed by Bruno Fierens