Some developers are skeptical of low-code platforms, and this skepticism is completely understandable due to the past limitations of these platforms in terms of flexibility and scalability. It has been difficult to conceal the bottlenecks of low-code platforms from developers, as they quickly discover the challenges when attempting to implement custom services for application scalability. However, the era of such limitations has finally come to an end. Thanks to the serverless development model, we can now address the major issues of low code, such as inflexibility and lack of maintainability.

Serverless is a cloud development model that empowers developers to build and deploy applications without the need to manage servers. The core concept behind serverless is that cloud providers, such as AWS and GCP, handle the tedious tasks of provisioning, maintaining, and scaling the server infrastructure on behalf of developers. This allows developers to focus solely on packaging their code in containers for deployment. In essence, serverless relieves developers from the burden of mundane and repetitive tasks, enabling them to concentrate on higher-level development activities.

Another significant advantage of the serverless model is its cost-effectiveness. With serverless, you only pay for the actual runtime of your service when it is triggered, rather than paying for a server that runs continuously in the background. By eliminating the need for dedicated servers, serverless architecture offers a more efficient and economical solution for running applications. As a result, customers can benefit from reduced costs on their invoices.

Now let's take a look at an example of implementing a service for sending text messages within an Acho application. The beauty of this approach is that you have the freedom to build your service in any programming language. In this particular example, we will be using JavaScript.

To achieve our goal, we simply need to create a function that accepts input from API calls and utilizes Twilio to send the desired message. This function acts as a bridge between your application and Twilio, enabling seamless communication.

const accountSid = "your_accountSid_here";
const authToken = "your_authToken_here";
const client = require("twilio")(accountSid, authToken);

const messagingServiceSid = "your_messagingServiceSid_here";

module.exports.sendTextMessage = (number, message) => {
  return client.messages.create({
    body: message,
    messagingServiceSid,
    to: `+1${number}`,
  });
};

const express = require("express");
const app = express();
app.use(express.json());
const { sendTextMessage } = require("./src/twilio");

app.post("/send-text-message", async (req, res, next) => {
  const { body } = req;
  const { phoneNumber, message } = body;

  sendTextMessage(phoneNumber, message)
    .then((msg) => {
      res.send({ status: "success" });
    })
    .catch((err) => {
      console.log(err);
      next(err);
    });
});

const port = process.env.PORT || 8084;
app.listen(port, () => {
  console.log("Resource insert listening on port", port);
});

With the endpoint and function in place for sending text messages, the next step is to trigger the API endpoint with the required parameters, phoneNumber and message. This allows you to dynamically send messages to different recipients with customized content.

Acho simplifies the deployment process for you, eliminating the need for complex deployment procedures. By leveraging Knative to run serverless containers in Kubernetes, Acho streamlines the deployment of your services. Whether you're deploying a new service or updating existing ones, it can be easily achieved with a single command.

Once the service is deployed as an Acho custom function, you can start using it by making API calls to the hosted endpoint.

By incorporating the dynamic parameters, such as phoneNumber and message, into the API call, we enable the application to pass specific values to the function we've implemented. This allows for flexibility and customization, as the application can provide different phone numbers and messages based on the context or user input.

Once the function is added to the custom API in App Builder, it becomes readily available as a selectable service within the API service options across your Acho Organization. This means that you can conveniently utilize the service in multiple applications and scenarios, ensuring its reusability and promoting efficient development practices.

After adding the custom API to the App Builder, you gain the ability to select the service from the available API services throughout your Acho Organization. This empowers you to use the service repeatedly in various applications and scenarios in the future.

To expand your services beyond sending text messages, you can always add more functions by hosting additional API endpoints. This flexible approach allows you to build and deploy unlimited services on Acho, catering to your specific needs and enabling you to unlock the full potential of the platform.

Here are some services that our clients run:

1. Realtime webhook: Host a webhook to
   • Return the data to the App
   • Push data to Acho resources
   • Trigger an alert to Slack, Teams, etc.
2. Chatbot messages (demo): Integrate natural language processing capabilities, automate customer interactions, and provide personalized responses based on user input
3. Image processing (demo): Host and run Python models for image recognition and object detection
4. Data transformation and integration: Transform the data and push it to another system such as CRMs or ERPs
5. Data Science: Host and run Python models for making predictions and returning the data for charting and further analysis.

What kind of services are you looking to build? Let me know Chat now