The latest Strapi-related news and major events happening for Strapi – including announcements, remote-work, organization and tips on running a start-up. 

Company

Engineering

The Tutorials section covers an introduction to Strapi, some advanced technical content, product updates and releases. From basic workaround to in-depth development guides. 

Tutorials

How tos

The Ecosystem section covers everything related to the world of Headless CMS and Strapi's place in it. 

Ecosystem

Get all the latest updates, news and events.

Subscribe to the newsletter 📣

large_Rust Vs. Other Programming Languages_ What Sets Rust Apart_.jpg

medium_Rust Vs. Other Programming Languages_ What Sets Rust Apart_.jpg

small_Rust Vs. Other Programming Languages_ What Sets Rust Apart_.jpg

thumbnail_Rust Vs. Other Programming Languages_ What Sets Rust Apart_.jpg

Rust Vs. Other Programming Languages_ What Sets Rust Apart_.jpg

Relational Databases: PostgreSQL Vs. MariaDB Vs. MySQL Vs. SQLite


## Introduction
Cloud computing is a software engineering paradigm centered around renting rather than purchasing the physical infrastructure required to run your software. Companies hosted their software on prepaid physical servers from the late 1990s to the early 2010s. They set aside a part of their budget to make this purchase before going public with their apps. This model, however, is expensive for companies just starting because they have to set aside a substantial part of their budget to purchase servers. Cloud computing started gaining prominence with the introduction of [EC2](https://en.wikipedia.org/wiki/Amazon_Elastic_Compute_Cloud) to the public in 2006. As the years progressed, more cloud providers entered the market, notably [Google](https://cloud.google.com/) in 2008 and [Microsoft](https://azure.microsoft.com/) in 2010. Now, we are at the point where software teams can spin up performant environments for their software applications in seconds rather than months.

When a software team wants to spin up an environment, they must consider the complexity and power it must possess. They can run their app on a virtual machine, a virtualized server created on an even more performant physical machine built for the cloud. They can also run it on a ready-made platform with their desired runtime already installed. If the app is small enough, they can run it as a serverless function. If budget is not a constraint, they can choose to purchase the application from a service provider and only pay subscription fees. Each method has pros and cons, and you must make the right choice that fits your requirements.

In this article, you will learn how to make the right choice when deciding how to build and deploy a web application. You learn this by studying the different models of deploying web applications, popularly known as cloud computing. These cloud computing models include Infrastructure as a Service (**IaaS**), Platform as a Service, (**PaaS**), Software as a Service (**SaaS**), and Functions as a Service (**FaaS**). You will learn about their features, pros, and cons. And finally, we will learn about Strapi Cloud.

## An overview of the different models
Different cloud computing models exist to address different needs. **IaaS**, for example, is used by customers who need a high level of customizability at the infrastructure level and don't mind the associated responsibility. **SaaS**, on the other hand, is restricted to customization only at the application level, with no customization at the infrastructure and platform levels. So you can customize the kind of virtual machine where your app is deployed in the **IaaS** model, but you can only customize how your app looks in the **SaaS** model.
All models have the same set of responsibilities, but these are shared differently by the provider and the customer. For **IaaS**, the provider is responsible for the physical machine's health, security, and uptime of all physical network devices. All other responsibilities such as the Operating System (OS) updates and data security are handled by the customer. As you move from **IaaS** to **PaaS** to **SaaS**, the responsibilities of the customer are reduced, and these responsibilities are transferred to the cloud service provider. The diagram below illustrates how responsibility is shared between the cloud service provider and the customer in the four models (traditional IT is also added for reference).

![001-comparisons-of-cloud-computing.png](https://api-prod.strapi.io/uploads/001_comparisons_of_cloud_computing_37235718cf.png)

The following section gives an overview of each model and their use cases.

## What is Infrastructure as a Service (IaaS)?
In the **IaaS** model, you are provided with a virtualized Infrastructure in the form of virtual machines, disks, and network devices (network interface card, firewalls, routers, etc) that you will configure to meet your requirements to run your software applications. In this model, you as the customer have the most responsibility. You manage your issued OS’ health, security, and updates. You are free to install and run different types of software, from runtimes like Node.js and Python to servers like Nginx and Apache 2. The major IaaS component is the virtual machine. Major cloud providers have different names for this. Azure calls it a "Virtual Machine", AWS calls it “Elastic Compute Cloud (EC2)”, and Google Cloud Platform calls it a "Compute Engine". 

When a customer provisions a virtual machine from a cloud provider, they access it using a bastion, an SSH session, or a remote desktop via RDP. They don't necessarily access it directly to install software and this process could be automated using configuration management tools like Ansible and Pulumi.

One specific use case of the IaaS model is for deploying software that would have otherwise been bought as a **SaaS**. There are many such software from email servers to databases. You can choose to deploy MySQL in your infrastructure rather than buying from a MySQL SaaS provider. Other things you can deploy using the **IaaS** model include Mattermost for team collaboration, [Apache Spark for data analytics](https://spark.apache.org/), and [SAP for Enterprise Resource Planning](https://community.sap.com/t5/enterprise-resource-planning-blogs-by-sap/a-do-it-yourself-step-by-step-guide-how-to-set-up-your-on-premise-system-of/ba-p/13352808). 

Another popular use case of the **IaaS** model is deploying web applications. Newer developers would be more familiar with using services like Heroku for this purpose which offers hosting services for popular web frameworks like Node.js, Python, and Ruby. This is a **PaaS** approach because one can host any type of web application, no matter the framework, on a virtual machine.

![002-typical-iaas-setup.png](https://api-prod.strapi.io/uploads/002_typical_iaas_setup_9cc854eb5f.png)

The machine simply needs the right configuration to run that particular type of web app. The typical approach is to define a pipeline that runs whenever code is committed to source control and take this code to the target virtual machine for deployment.

Summary of IaaS:

| **IaaS**    | **Features**                 |
| ----------------------------- | ------------------------------------------------------------------------------ |
| **Virtualized Resources**     | Offers customizable virtual machines, storage, and networking.                 |
| **Customer Responsibilities** | Manages OS maintenance, security, and software installations.                  |
| **Access Methods**            | Accessed via bastion hosts, SSH, or RDP with configuration automation tools.   |
| **SaaS Alternative**          | Provides infrastructure to host and manage traditional SaaS applications.      |
| **Web Deployment**            | Enables hosting and control of web applications beyond typical PaaS offerings. |
| **Automation and Scaling**    | Supports automated deployments and scalability through CI/CD pipelines.        |


## What is Platform as a Service (PaaS)?
In the **PaaS** model, the cloud provider provides the runtime needed to run apps built with languages such as Python, JavaScript, Java, and Ruby. For a framework like Python with two major versions, the provider makes both versions available so that developers have an easier time getting their app to production. Under the hood, the **PaaS** environment runs the code in a virtual machine or a [container](https://cloud.google.com/learn/what-are-containers) but access to the machine is oftentimes restricted to the customer. 

Depending on the provider, one can deploy a container directly to production using the **PaaS** approach. The general idea is to containerize your application locally, push the resulting [container image](https://www.techtarget.com/searchitoperations/definition/container-image) to a [container registry](https://www.redhat.com/en/topics/cloud-native-apps/what-is-a-container-registry) like [Dockerhub](https://hub.docker.com/), and configure the **PaaS** platform to pull this image and run it as an application.

![003-paas-deployment.png](https://api-prod.strapi.io/uploads/003_paas_deployment_ae1bad8b61.png)

In both approaches of using virtual machines or containers, you are expected to build your application in a way that doesn’t store the application state on the machine because the environment can be torn down and built back up without notice. If your application writes to disk, you may encounter a data loss problem.

Summary of **PaaS**:

| **PaaS**  | **Features**          |
| ------------------------- | ---------------------------------------------------------------------------------- |
| **Runtime Provisioning**  | Provides runtimes for languages like Python, JavaScript, Java, and Ruby.           |
| **Version Support**:      | Offers multiple versions of frameworks, e.g., both major versions of Python.       |
| **Environment Access**    | Runs apps in VMs or containers with restricted customer access.                    |
| **Container Deployment**: | Allows deploying containerized apps directly from registries like Dockerhub.       |
| **Stateless Design**      | Requires apps to be stateless to avoid data loss during dynamic environment change |


## What is Functions as a Service (FaaS)?
The **FaaS ** model is similar to the **PaaS** model in that the application is written in one language and deployed to an environment where it gets a Fully Qualified Domain Name (FQDN). It is however different in that only a small portion of an application is deployed. Typically, this is the portion that does a unit of work, abstracted as a function. This is why applications deployed using this model are called Serverless Functions. 

![004-faas-model.png](https://api-prod.strapi.io/uploads/004_faas_model_703469ccee.png)

The constraints of writing to disk and persisting application state are more apparent in this approach. It forces the developer to take the approach of writing their application to communicate with an external state be it a database, object storage service, or message queue. 

Summary of FaaS:

| **FaaS**      | **Features**                 |
| ----------------------------- | -------------------------------------------------------------------------- |
| **Language Consistency**      | Uses one programming language for application development.                 |
| **Deployment**                | Assigns a Fully Qualified Domain Name (FQDN) to deployed functions.        |
| **Function-based Deployment** | Deploys small, function-sized units of an application.                     |
| **Serverless Architecture**   | Functions are managed without dedicated servers by the provider.           |
| **State Management**          | Necessitates external state management, e.g., databases or message queues. |


## What is Software as a Service (SaaS)?
In the **SaaS** model, the customer only pays for the maintenance, support, security, and updates to the software as covered by their license or subscription. The typical deployment approach is a single click through the website of the provider. The **SaaS** model has most of the responsibility on the provider and the least responsibility on the customer. The customer is in charge of their data security but not in charge of the OS or Infrastructure security.
Examples of **SaaS** software or **SaaS** products include Office 365, a document collaboration suite, Dropbox, a file storage service, and Slack, a corporate collaboration software. All these **SaaS** software require some form of subscription or license to be used. For the most part, the provider tries to optimize costs for the customer. In many cases, the customer only benefits from hosting their software themselves if they can optimize their virtual machine usage. When scale matters, it might make sense to use the **IaaS** option instead.

Summary of **SaaS**:


| **Saas**         | **Features**   |
| --------------------------- | --------------------------------------------------------------------------------------- |
| **Cost Structure**          | Customers pay for maintenance, support, security, and updates via subscriptions.        |
| **Easy Deployment**:        | Typically offers single-click deployment through the provider's website.                |
| **Provider Responsibility** | Most responsibilities, except data security, lie with the provider.                     |
| **Customer Responsibility** | Customers are mainly responsible for their data security.                               |
| **Examples**                | **SaaS** products Includes Office 365, Dropbox, and Slack, mostly requiring subscriptions.                |
| **Cost Optimization**       | Providers aim to optimize costs; self-hosting is beneficial only with efficient VM use. |
| **Scaling Considerations**  | **IaaS** may be preferable when scaling is a critical factor.                               |

## Deployment Considerations

When deciding on a deployment model, consider aspects like the duration of service operation, memory consumption, and scaling requirements. These considerations are vital because each deployment model is tailored for different use cases, prompting you to ask relevant questions about your particular needs and assisting in selecting the best-suited model. It's worth noting that not all software can be deployed using both the **IaaS** and **SaaS** approaches. Some software must be obtained using a strict SaaS approach where the customer simply pays the organization and has access to the software. However, with cloud deployment, you typically have the flexibility to choose between **IaaS**, **PaaS**, and **FaaS** options. In this section, you will learn about the different factors that influence the choice of a cloud deployment model.

### Technical know-how
When your team consists of system administrators who can easily automate, patch, and manage machines in your network, you can easily choose to use an **IaaS** model. Because people in your team already have the technical know-how to deploy and manage applications on virtual machines, you won't face troubles when you need to troubleshoot. In some instances, your organization already has the physical infrastructure it uses to run applications but wants to connect this physical infrastructure to the cloud. In such cases, you would consider using the **IaaS** model so you can easily replicate on-prem software to the cloud.

When you have less experienced system administrators or simply run a team with just developers, you should consider using the **PaaS** model. In this way, developers are responsible for managing their code and releases without worrying about the underlying infrastructure. The same consideration applies to **FaaS** since it's very similar to the **PaaS** approach. The purpose of deploying an application is to get value to consumers as fast as possible. So, when you can use a platform configuration to achieve this, you should go for it using your existing manpower. 
For teams with limited technical expertise, the **SaaS** approach is a wise choice. This model relieves you of the burden of managing code, deployments, and security updates, among other tasks. Your sole focus is on application data and data security, simplifying your responsibilities and allowing you to concentrate on what matters most.

### Scalability consideration
Each deployment model comes with a scalability option built in. For **IaaS**, your virtual machine instances can either scale up (vertical scaling) or scale out (horizontal scaling). Scalability is oftentimes handled by scaling rules where the environment scales based on the number of connections, CPU utilization, request rate, response time, etc. 
For **PaaS**, scalability is more or less integrated into the environment, and the way the app scales determines the bill at the end of the month/defined billing period. As with other aspects of **PaaS**, scalability adopts the platform defaults and can more easily be configured to suit a user’s needs.
For **FaaS**, scalability is automatic based on the number of connections and the customer doesn’t have to configure anything. This is similar to **SaaS** where the customer simply provides the application for the users without worrying about connections, number of instances, CPU utilization, etc. 

### Costs
The cost of a platform is a major consideration factor when deciding the deployment method to adopt. Software teams can save costs if they optimize their virtual machines to run more than one software be it websites or enterprise applications. For example, a single 4 GB RAM virtual machine can be used to run 3 websites for a mid-sized company. When the team does not have the technical know-how to optimize costs for virtual machines, the next reasonable approach is to pay for a **PaaS** solution or simply pay for a **SaaS** that addresses their needs. With either approach, they spend less time worrying about optimizing infrastructure costs and more time optimizing application code in the case of **PaaS**, or optimizing which users are served in the case of **SaaS**. 

### Configuration Tips for Optimal Performance
To optimize performance you need to consider your chosen deployment method and how performance is generally optimized in it. For an **IaaS** workload, for example, you should choose an instance that fits your workload based on CPU, memory, and storage. 
If your deployment spans across multiple virtual machines, you spread your load across multiple instances using an appropriate load-balancing technique. 
If your load varies based on the time of day you should consider scaling instances automatically by provisioning more instances when the load is higher and deprovisioning extra instances when the load is lower.
You should consider implementing firewall protection, encryption, private subnets, and regular updates to ensure your infrastructure is protected at all times.
If you are utilizing a **PaaS** approach you should consider using a managed database service from your cloud provider to reduce latency and ensure zero data loss. You should also cache frequent requests to ensure your instance stays fast.

## Strapi Cloud as a PaaS

[Strapi Cloud](https://cloud.strapi.io/) offers a unique Platform as a Service (**PaaS**) solution distinct from typical Software as a Service (**SaaS**) Headless CMS. On top of providing a Strapi-optimized stack including database, email provider, and CDN (Content Delivery Network) out of the box, Strapi Cloud gives the flexibility to customize your infrastructure to suit specific project needs, including the ability to integrate custom plugins and APIs. This enables developers to maintain control over their development environment, optimizing for both functionality and performance.

Strapi Cloud simplifies operations by managing infrastructure tasks such as CDN caching, backups, and scalability — features that automatically adjust resources to handle increased loads without user intervention. Click [here](https://cloud.strapi.io/login) to try Strapi cloud today.

## Conclusion

In this article, you explored the different models of deploying applications to the cloud. These models include Infrastructure as a Service (**IaaS**), Platform as a Service (**PaaS**), Functions as a Service (**FaaS)**, and Software as a Service (**SaaS**). Each model has its quirks and use cases. Your major takeaway is to realize that these models exist and should be used where appropriate to deploy applications to the cloud. 

Also, with Strapi Cloud you can get everything you need to run a Strapi in production, deploy a Strapi project to production in just a few clicks, and still remain in complete control. 



IaaS vs PaaS vs SaaS: The Key Differences

**JavaScript** is widely known as the programming language of the web. It is used to build full-stack web applications, both client-side and server-side. 

In 2012, Microsoft Corporation released another language called **TypeScript**, which adds static typing to JavaScript. Although developers have used it for many years, TypeScript is also becoming popular among developers due to its enhanced features that support building large-level applications.

[Strapi is the leading open-source headless CMS](https://strapi.io/). It has supported JavaScript in previous versions, but in v4.3.0, [TypeScript support was announced](https://strapi.io/blog/strapi-v4.3-with-typescript-and-media-library-folders-is-live). 

This article will explore JavaScript and TypeScript, their differences, and the pros and cons of using them with Strapi.

## What is JavaScript?
JavaScript is a dynamic scripting programming language known as the **language of the web.** It is mainly used to develop the client and server side of web applications. It adds interactivity, timely content display, image animations, etc, to web pages. Its uses have evolved over the years with different frameworks invented, and it is also used for mobile apps and games development.

## What is TypeScript?
Due to some of the limitations of JavaScript over the years, such as building high-level applications, Microsoft developed TypeScript in 2012. [TypeScript is an enhanced version of JavaScript](https://strapi.io/blog/what-is-typescript) that adds static typing to it; it is a superset of JavaScript and supports most of its libraries. It doesn’t run in a browser; hence, its codes is compiled into JS.

## TypeScript vs JavaScript
JavaScript and TypeScript have similarities and differences, depending on their use cases. While JavaScript is used to build dynamic and interactive web pages, TypeScript was introduced to overcome the complexity of building large and medium-sized applications.

Below are some of the main differences between them:

| **TypeScript**                                                                                                         | **JavaScript**                                                                                                                                 |
| --------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| TypeScript code needs to be compiled.                                                                                  | JavaScript doesn't need to be compiled.                                                                                                        |
| TypeScript is a strongly-typed language and performs all types check before compiling the code.                       | JavaScript is loosely-typed language and supports only dynamic typing; hence, all type checks are performed only when the program is executing. |
| TypeScript files end with `.ts`.                                                                                         | JavaScript files end with `.js`.                                                                                                                 |
| TypeScript doesn’t run on the browser directly and needs to be converted to JavaScript.                                | JavaScript runs directly on the browser and supports cross-platform development.                                                               |
| TypeScript uses concepts like types, interfaces, OOP, and other enhanced features.                                     | JavaScript is just a scripting language for the web with no support for interfaces.                                                           |
| TypeScript has a stiff learning curve and is not easy to learn and hence not as popular in the developer’s community. | JavaScript is a fundamental language in frontend development that is easy to learn and has a wide community of developers.                    |

Now, let’s see some of the differences by writing a simple function in both languages: 

```js
    let a = 10;
    let b = 5;
    function addNum(a, b) {
        return a + b
    }
    console.log(addNum(a, b))
    
    //output: 15
```
In the code above, I created a function `addNum` in JavaScript to add two numbers. Let’s replicate this in TypeScript.

```ts
    let a: number = 10;
    let b: number = 5;
    
    function addNum(a:number, b:number): number {
        return a + b
    }
    console.log(addNum(a, b))
    
    //output: 15
```

In the TypeScript code, I had to declare each variable's types and function parameters' types and their return value. I can reassign the variable `a' into another data type, maybe string in my JavaScript code. For TypeScript, I can’t reassign directly to another type of data except with [TypeScript assertion](https://www.tutorialsteacher.com/typescript/type-assertion).

![typescript is a superset of javascript](https://paper-attachments.dropbox.com/s_62B5E62B2360C2C22F9ED41D2E77079E45D8D290D4BEE12030011ECF04B9015B_1664703125809_E9830885-02DA-4A27-B843-38CE03B42C89_1_201_a.jpeg)



## What is Strapi?
Strapi is an open-source content management system that enables the development of websites, mobile applications, e-commerce sites, and APIs-REST and Graphql without knowing anything about the backend or database. 

It is developer-friendly, simple, and easy to use. It supports both JavaScript and TypeScript. Strapi also supports JavaScript and TypeScript frameworks like React, Angular, Svelte, Vue.js, etc.

## Pros and Cons of Using Strapi with JavaScript
Strapi was fully developed in JavaScript; hence, it has great support for it and its frameworks. It is used in building data models and generating CRUD APIs for JavaScript web and mobile apps.

Here are some of the advantages and disadvantages of using JavaScript with Strapi:

### Advantages
1.**Speed**: JavaScript is a fast language that doesn’t need to be compiled, which makes development and debugging faster. Using it with Strapi for the client side of applications makes developing applications easier. 

2.**Frameworks Support**:  Strapi supports almost all JavaScript frameworks like React.js, Next.js , Vuej.s, Nuxt.js, etc. It makes it easy to easily Bootstrap your application with any framework without worrying about the backend.

3.**Rich Interfaces**: JavaScript provides an eye-catching appearance and rich interfaces for users to interact and engage. While Strapi gives you out-of-the-box documented REST and Graphql APIs, you can easily create rich client-side interfaces to integrate the APIs.

4.**Popularity**: JavaScript is popularly known and has a large community of developers. It makes it easy to start building with Strapi because of the many online resources available.

### **Disadvantages**
1. **Security**:  JavaScript mainly runs on the browser, which makes it accessible to anyone. The security of those codes is at stake and it can be exploited for malicious purposes.
 
2.**Inconsistency in the browser**: JavaScript code is interpreted differently on different browsers and this can lead to the users having inconsistent experience from the Strapi server. 

3.**Render Issue:** JavaScript is a sensitive language, which means any small error in the code can crash the entire webpage and not render it at all.

## Pros and cons of using Strapi with TypeScript
Strapi added TypeScript support for new projects on v4.3.0 and above. It makes it easy for developers to add TypeScript typings to JavaScript code. Old and existing JavaScript projects in Strapi can also use TypeScript through [the conversion procedure](https://docs.strapi.io/developer-docs/latest/development/typescript.html#add-typescript-support-to-an-existing-strapi-project).

Let's look at some of the advantages and disadvantages of using Strapi with TypeScript

### Advantages
1.**Static Typing**: Unlike JavaScript, which is dynamically typed, using TypeScript with Strapi makes it easy to add types to declared variables. Static typing means a variable cannot be changed or given certain values once declared. For example, a variable declared as an integer cannot be used as a string or assigned to another data type. It results in fewer error codes in production and reduces type-related mistakes.

2.**Data Binding**: TypeScript makes it easy to know the data type and what form a component should expect. It makes it easy to define interactive applications and eases communication between the TypeScript code and the template that the user sees.

3.**Enhanced Features**: TypeScript has more features like interfaces, OOP, classes, etc. It makes it beneficial for large-scale projects and gives better app development. It also has rich IDE support with autocomplete and code-navigation features. Also, since TypeScript is a superset of JavaScript, every new JavaScript feature becomes its feature. 

### Disadvantages

1.**Compilation Issue:** TypeScript requires compilation each time to run properly, which can take a long time leading to a slower development process. Also, it can’t run on the browser directly; hence, it needs to be compiled into JavaScript before executing it in the browser.

2.**Complicated Typing System**:  To use TypeScript effectively with Strapi, developers need to define types everywhere, which might become cumbersome for someone from a background in a dynamic language like JavaScript. 


## Conclusion 
While JavaScript is still widely used in the developer's community, TypeScript is preferable for medium and large-sized projects due to its significant benefits. This article has explored what TypeScript and JavaScript are, their main differences, and the pros and cons of using each with Strapi.









Learn the differences between JavaScript and TypeScript and which one you should use with Strapi.

TypeScript vs JavaScript: Which One Should You Use With Strapi?

Check out the following related blog posts.

Rust Vs. Other Programming Languages: What Sets Rust Apart?

I am a Backend developer and Technical writer with over 2 years of experience in both fields. I often share my experiences in tech and I love what I do.