Skip to main content

Essentials for backend development

What is back-end development?​

Back-end development means working on server-side software, which focuses on everything you can’t see on a website. Back-end developers ensure the website performs correctly, focusing on databases, back-end logic, application programming interface (APIs), architecture, and servers. They use code that helps browsers communicate with databases, store, understand, and delete data.

How to become a Backend Developer?​

Learning back-end development helps you get acquainted with several programming languages, which can provide a great boost to your career. If you have a basic understanding of how logic works, it can prove to be quite beneficial. There are many components involved in Backend development that you, as a backend engineer, must know about.

Some of the essential knowledge for a backend engineer includes:

Understanding how the internet works:​

As a backend developer you must know how the internet works and what actually happens when you develop an API and when it's used by your Front-end team. What different protocols are used e.g. HTTP, TCP, UDP etc.

Here are some resources that you may find helpful in learning more about Internet:

Choosing a programming language​

There are a number of languages available for backend development. Even javascript, which originated as a language for interacting with the Front-end, can now be used for making large scale backend applications with the help of frameworks like NodeJS, Deno etc.
Some popular languages used on the backend include

  • JAVA
  • JavaScript
  • Python
  • GoLang and many more

Whichever language you choose, make sure to go through the official documentation by visiting thier website to get a basic idea on how to get started with that specific language.

Selecting a language is the first step. Each language provides its own frameworks and libraries to help make your backend development experience a lot better. For example, Python has DJango framework, Javascript has NodeJS, JAVA has Spring/Spring-boot framework etc. After you're done with the language fundamentals, next step is to learn a framework.

Understanding of version control systems​

Version control/source control systems allow developers to track and control changes to code over time. These services often include the ability to make atomic revisions to code, branch/fork off of specific points, and to compare versions of code. They are useful in determining the who, what, when, and why code changes were made. One of the most popular version control system used is Git. To learn more about version control, you can checkout this article

Working knowledge of different databases (Either SQL and NoSql)​

As a backend developer your database knowledge must be excellent. While working with a database, wether it's SQL or NoSql, you must be well versed in querying data and forming associations between entities. In case of an SQL database like MySql, you must have a sound knowledge of writing SQL queries, defining schemas, creating relationships b/w the tables in your schema and so on.

A NoSql database like MongoDB is a "non-relational" database which basically means that it does not use the tabular schema of rows and columns found in most traditional database systems. Instead, non-relational databases use a storage model that is optimized for the specific requirements of the type of data being stored.

While working with any language/framework, you'll most likely be using an ORM or ODM in case of a NoSql database. So similar to learning a language, you must first familiarize yourself with the database fundamentals of the DB that you choose and then afterwards learn about the ORM/ODM most suitable for your work. E.g. ORMs like Sequelize, TypeORM and Prisma are popular among the SQL community while working with mongoDB you'll most probably use mongoose, which is an ODM for working with MongoDB.

Main purpose of using an ORM/ODM is allow the developer to manipulate data in DB without having to write raw queries but rather use the Object-Oriented paradigm. It encapsulates the code needed to communicate with the database, so you don't use queries anymore; you interact directly with an object in the same language you're using.

Understading APIs​

API stands for Application Programming Interface, which is a set of definitions and protocols for building and integrating application software.

APIs let your product or service communicate with other products and services without having to know how they’re implemented. This can simplify app development, saving time and money. When you’re designing new tools and products—or managing existing ones—APIs give you flexibility; simplify design, administration, and use; and provide opportunities for innovation. To learn more about APIs, checkout this article.

API Authentication/Authorization​

API authentication and Authorization are vital part of building an API. These define the security of your API i.e. who is allowed to access to your API.

The API authentication process validates the identity of the client attempting to make a connection by using an authentication protocol. The protocol sends the credentials from the remote client requesting the connection to the remote access server in either plain text or encrypted form. Any sensitive information is encrypted/hashed before storing in DB. Authentication can be implemented in many ways, which include:

Authorization is the process of identifying the role of the user trying to access the system i.e. do they have the privilages to perform certain actions of not.

Advanced Concepts​

Architectural Patterns​

The most common definition of an architectural pattern would be that it is a general, reusable solution to a commonly occurring problem in software architecture within a given context. Architectural patterns are similar to software design pattern but have a broader scope. There are a number of patterns around. You might even have heard of some of them like the Client-server or Master-slave pattern etc. We will discuss some of the most commonly used architectures in backend application development i.e. Monolithic, Micro-Services and Serverless architectures.

Monolithic Architecture​

Monolithic architecture is a pattern in which an application handles requests, executes business logic, interacts with the database, and creates the HTML for the front end. In simpler terms, this one application does many things. It's inner components are highly coupled and deployed as one unit.

Monolithic architecture is a unified development model for software applications. It has three components:

  • Client-side user interface
  • Server-side application
  • Data interface

All three parts interact with a single database. Software built on this model operates with one base of code. As a result, whenever stakeholders want to make updates or changes, they access the same set of code. This can have ripple effects that impact user-side performance.

Micro-Services Architecture​

Microservices architecture (often shortened to microservices) refers to an architectural style for developing applications. Microservices allow a large application to be separated into smaller independent parts, with each part having its own realm of responsibility. To serve a single user request, a microservices-based application can call on many internal microservices to compose its response.

Containers are a well-suited microservices architecture example, since they let you focus on developing the services without worrying about the dependencies. Modern cloud-native applications are usually built as microservices using containers.

To learn more about Micro-services and Monolithic architecture and the difference/pros-cons between the two, checkout this article

Serverless Architecture​

Serverless is a cloud application development and execution model that lets developers build and run code without managing servers, and without paying for idle cloud infrastructure. Serverless lets developers put all their focus into writing the best front-end application code and business logic they can. All developers need to do is write their application code and deploy it to containers managed by a cloud service provider. The cloud provider handles the rest, provisioning the cloud infrastructure required to run the code and scaling the infrastructure up and down on demand as needed. The cloud provider is also responsible for all routine infrastructure management and maintenance such as operating system updates and patches, security management, capacity planning, system monitoring and more.

Although its name does suggest 'no servers', but that is not the case. There are most definitely servers in serverless computing. 'Serverless' describes the developer’s experience with those servers—they are are invisible to the developer, who doesn't see them, manage them, or interact with them in any way.

To learn more about Serverless Architecture, checkout this article on Serverless on AWS or watch this video to understand the architecture better.