Building an Application Programming Interface, or API, is an interesting project, especially when you want to manipulate data in the backend of a website or simply hone your skills in web development.

In this article, we will build an API using Express, a NodeJS web framework, and then we will deploy it to Railway for free.

# What is an Application Programming Interface (API)

An Application Programming Interface (API) is a type of program or piece of software that connects two or more applications together.

![a waiter serving a customer in a restaurant](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2FApplication-programming-%20interface.png)

Imagine a waiter at a restaurant. This waiter is like an API. It asks the customer what food to order. The customer can be anything, for instance, a React website or even a mobile application.

When the customer finishes the order, the waiter will go to the kitchen to tell the chef what to cook. This is like the API telling the database what data to fetch.

When the chef is done cooking, the waiter will get the food from the chef. In this case, the API will fetch the data from the database.

Finally, the waiter will give the food to the customer. In our example, the API will now give the data to a frontend application like `React`.

# Build an API using Express

Before we get our hands dirty with coding, let's first create a repository on Github. 

## 1. Create a Github Repository

I will name my repository as `my-api` and then write a description as follows, `This is an API created using NodeJS & Express to be deployed to Railway.`.

Check the `Add a README file` checkbox and then choose `Node` for the `.gitignore template`, like below.

![create Github repository of the API](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Fcreate-repo.PNG)

Click `Create repository`.

Github will automatically redirect you to the new repository.

![new Github repository of the API](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Fcreated-repo.PNG)

## 2. Clone the Repository on your Computer

Let's use the `SSH` to connect to our repository. Open up your terminal and clone the repository.

```
git clone git@github.com:<username>/my-api.git
```
> Replace `<username>` with your Github username.

In my case, it will be:

```
git clone git@github.com:naknamu/my-api.git
```

![clone the repository](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Fgit-clone.PNG)

Now, go to the local repository saved in your computer.

```
cd my-api
```

## 3. Create an Express Application

Let's initialize our project by using the command below.

```
npm init -y
```

!["npm init -y" in the console](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Fnpm-init-y.PNG)

The command above creates a `package.json` file. It contains information like the name, version, and list of all the dependencies used by the project.

Now, it's time to install express.

```
npm install express
```

Notice that there is a new file called `package-lock.json` and a folder named `node_modules` that were created.

The `package-lock.json`, captures the exact versions of packages and their dependencies in your project. The `node_modules`, on the other hand, contains the files of the dependencies or libraries that are used by your project, for instance, the `express` module.

Create a new file called `index.js`. Add the following code:

```js
const express = require("express");
const app = express();
const port = process.env.PORT || 3000;

app.get("/", function (req, res) {
  res.send("Hello World!");
});

app.listen(port, function () {
  console.log(`Express app listening on port ${port}!`);
});
```

In the code above, we imported the `express` module using the built-in `require()` function. Then, we created a new express application using the `express()` method and assigned it to the variable `app`. You can name it anything you want, although traditionally it's named `app` for familiarity and simplicity. 

In the next line of code, we created an `OR` condition so we could choose what port our app would listen to. Either a port stored in an environmental variable called `PORT` or simply the port `3000`.

Now, the `app.get()` method is an express function that invokes a callback function whenever there is an HTTP `GET` request for the path `"/"` relative to the site root. For example, when you request `http://localhost:3000/`, the callback function inside `app.get()` will be triggered.

The callback function, `function(req, res) {}`, takes two arguments: the request object, `req`, and a response object, `res`. The `res.send("Hello World!")` will be invoked as a response whenever `app.get()` is called.

Finally, we used the `app.listen()` function to start the server on the port we initialized a while ago, which is `process.env.PORT` or `3000`. 

We then added a callback function that prints `Express app listening on port ${port}!` to the console when the server is successfully running.

Let's run our express application by using the command below.

```
node index.js
```

If successful, you'll see the message in the console, like so:

![message from the console](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Frun-express-app.PNG)

Now, go to `http://localhost:3000/` in your browser, and you will see your Express app running. Congratulations! 🍻

![Hello world in the browser](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Fget-response-browser.PNG)

## 4. Push Changes to the Github Repository

Before we deploy our Express app, let's add, commit, and push the changes to our Github repository.

Check the status of our project by using the command.

```
git status
```

![check the status of the project](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Fgit-status.PNG)

Add all the files to be commited.

```
git add .
```

Commit to the repository.

```
git commit -m "Initial commit"
```

And then, push our changes, like so:

```
git push
```

![git push the files to the Github repository](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Fgit-push.PNG)

You can check again the status by using `git status`. It will throw a message, like this:

```
On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean
```

Go to your repository on Github to see the changes.

![new files added to the Github repository](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Fupdated-repo.PNG)

# Deploy our Express app to Railway

Our app is now ready for deployment on [Railway](https://railway.app/). 

I have three API's currently deployed on Railway, and I don't even pay a single cent.

![three project usage on railway](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Fthree-project-usage.PNG)

*How is this possible?* It's because I am subscribed to their `Hobby Plan`, which includes a `free $5 of usage monthly`. The three APIs's total costs don't even reach $4 by the end of the month. Check out all my project usage below from March 31 to May 1.

![total project usage on railway](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Frailway-usage.PNG)

You can see that my `Estimated Bill` is `$ 0.00`.

> These three API's were also created using Express.

## 1. Sign up for a New Account on Railway

Create an account on Railway by using your email or by connecting it through your Github account. I suggest connecting your Github account so you can deploy from the Github repository easily.

![create new account on railway](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Frailway-create-account.PNG)

## 2. Create a New Project on Railway

Let's create a new project on Railway by deploying from the Github repo we created a while ago.

Click `Deploy from Github repo`.

![new project on Railway](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Frailway-new-project.PNG)

Then click `Configure Github App`. Sign in to your Github account. You can choose to give access to `All repositories` or `Only select repositories`. In my case, I'll choose `Only select repositories`, like so.

![only select the my-api repository](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Frailway-only-select-myapi-repo.PNG)

Click `Save`. Now, go back to Railway and you'll see the repository `my-api` in the choices.

![the repo appeared on Railway](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Frailway-repo-appeared.PNG)

Click the repository, my-api, and then click `Deploy Now`.

That's it! You have successfully deployed an API on Railway! 🎉

![successful deployment on Railway](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Frailway-successful-deployment.PNG)

## 3. Generate a Domain on Railway

Now, if you want to see your API in the browser, you must generate a domain on Railway, and it's quite easy.

Just click `Settings`. Scroll down to `Networking`, and under `Public Networking`, click on `Generate Domain`.

![generate a domain on Railway](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Frailway-generate-domain.PNG)

Wait for a second, and there you go. You have now generated a domain for your API.

Follow that link and you'll see your API live in the browser. Congratulations! 🍻

![API in the browser](https://image.solodevhub.com/solodevhub%2Fbuild-deploy-api-railway%2Frailway-API-in-the-browser.PNG)

## Wrapping up

The Express app that we have built in this article is very simple. You can expand this API by having the ability to store data in a database like `MongoDB` or by creating many routes that handle `POST` requests from users. The sky is the limit!

The purpose of this blog was to show you the end-to-end process of developing an API from scratch using Express and deploying it to production using Railway.

Anyway, I hope you learned a lot in this tutorial, and I hope I can write more awesome guides like this in the future. Until next time, cheers! 🍺