Backend refers to the logic and functions that happen behind the scenes but is necessary for the user to be able to send and receive information back and forth between the frontend and the database. Often used for server-side rendering as opposed to client-side rendering which is processed by the frontend, both of the elements work in tandem to provide for a well-functioning and efficient application. Backend developers build the “under the hood” parts of websites or mobile apps that users don’t interact with directly. This means that a back-end developer must be able to write code to receive the information input from the user and also save it somewhere – like in a database (relational or non relational).
It includes all the code needed to build out the database, server, and application. From database migrations to API integrations to setting up the server-side technologies that make a website tick.
- Working knowledge of back-end development (configuration, administration and management of databases and servers)
- Security and authentication best practices
- Back-End Tools and Technology
- Experience writing RESTful APIs
- Client-server general overview
- WEb servers
- Middleware
- APIs
- Postman app
- Token-based Authentication and Single Sign-on
- JSON Web Token (JWT)
- Security Assertion Markup Language (SAML)
| Name | Type | Short Description |
|---|---|---|
| The Beginner’s Guide to Backend Development | article | The Beginner’s Guide to Backend Development |
| What is back-end? | video | What is back-end? |
| What is a web server? | article | What is a web server? |
| Rest API Definition for Beginners | article | Rest API Definition for Beginners |
| What Are APIs? - Simply Explained | video | What Are APIs? - Simply Explained |
| Understand the Difference Between SOAP and REST APIs | video | Understand the Difference Between SOAP and REST APIs |
| Middleware. NestJS - A progressive Node.js framework | article | Middleware. NestJS - A progressive Node.js framework |
| What is an API and how does it work? | video | What is an API and how does it work? |
| Node.js Crash Course Tutorial #8 - Middleware | video | Node.js Crash Course Tutorial #8 - Middleware |
| Best practices for REST API security: Authentication and authorization | article | Best practices for REST API security: Authentication and authorization |
| JSON vs XML | article | Read short article about JSON and XML comparison |
| A Comprehensive Guide To Backend Tech | article | A Comprehensive Guide To Backend Tech |
| Most Used REST API Authentication Methods | article | Read about most used REST API Authentication methods |
| Awesome list of GraphQL | article | Awesome list of GraphQL |
| The Fullstack Tutorial for GraphQL | video | The Fullstack Tutorial for GraphQL |
| OWASP Top Ten | article | Top 10 Web Application Security Risks |
| Name | Type | Short Description |
|---|---|---|
| Docker Tutorial for Beginners | video | Get started using Docker with this end-to-end beginners course with hands-on labs. |
As a backend developer, understanding databases is a crucial part of your job, as data storage and retrieval is often one of the primary tasks of a backend system. SQL and NoSQL databases are two of the most popular types of databases used in modern software development. Here are a few reasons why a backend developer should learn about both:
SQL databases: Structured Query Language (SQL) is a standard language used to manage and manipulate relational databases. SQL databases are ideal for handling structured data and are used by many businesses for their reliability and data consistency. As a backend developer, understanding SQL databases can help you create efficient, scalable, and reliable applications. Additionally, SQL is a widely used language that is not specific to any particular database system, so knowledge of SQL can be applied across multiple database platforms.
NoSQL databases: NoSQL databases are designed to handle unstructured or semi-structured data, which can be a better fit for certain types of applications, such as those that require high scalability or real-time data processing. As a backend developer, learning about NoSQL databases can help you identify when this type of database is more appropriate for your application needs. NoSQL databases also offer a flexible schema design, which means you can quickly iterate and change your data model as needed, which is useful for agile development.
Hybrid solutions: In some cases, a combination of SQL and NoSQL databases may be the best solution for an application. Understanding both types of databases can help you design more complex systems that take advantage of the strengths of each type of database. For example, you might use a SQL database to store structured data, while using a NoSQL database for unstructured data or as a caching layer.
In summary, backend developers should learn about both SQL and NoSQL databases because they each have their own strengths and weaknesses, and understanding how to use them effectively can help you build more robust and scalable applications.
- Fundamentals Structured Query Language
- Tables, Views, Stored procedures
- Indexes
- Joins, Groups
- Storage subsystems, Transactions
| Name | Type | Short Description |
|---|---|---|
| Introduction to SQL, noSQL databases | article | Introduction |
| SQL fundamentals | tutorial | SQL fundamentals |
| What is nosql? | video | noSql |
| noSql mongodDB | tutorial | noSql |
| stored procedures | article | stored procedures |
| views | article | views |
| views | article | views |
| indexes | article | indexes |
| Transactions | article | Transactions |
Node.js is a powerful and popular runtime environment for server-side JavaScript applications. It allows developers to use JavaScript to build high-performance, scalable, and efficient network applications, such as web servers, APIs, and real-time applications.
Node.js provides a wide range of built-in modules that can be used to perform various tasks, such as file I/O, networking, cryptography, and more. It also has a vibrant ecosystem of third-party modules and packages that can be easily integrated into applications, making it a popular choice for developers across a range of industries.
- Installing / configuring IDE
- V8, libuv, Event loop, worker threads, child_process
- Module System (commonJS, ES, global / module vars)
- Node.js async development / Control flow
- Node.js Profiling and Debugging
- Communication Protocols (http vs https, ws, rest, graphql)
- Node.js secure app (CORS, JWT, OAuth?) (Experience in Implementing Data Protection)
- Node.js package managers
- Events
- Buffer and Streams
- Error handling
- Node.js logging approaches
- Working with file system
- Node.js unit / integration testing (creating reasonable and valuable unit-tests) (Understanding the principles of software design, unit and integration testing.)
- Diagnostics (debugging, tracing, profiling, step debugging)
- Creating RESTfull services
- Http,rest(min) performance
| Name | Type | Short Description |
|---|---|---|
| V8 Node.js documentation | documentation | V8 Node.js documentation |
| How to set up VS Code for Node.js development | video | How to set up VS Code for Node.js development |
| Node.js Under The Hood | article | Node.js Under The Hood |
| CommonJS vs. ES modules in Node.js | article | Comparing CommonJS modules and ES modules |
| Understanding Async Programming in Node.js | article | Understanding Async Programming in Node.js |
| Easy profiling for Node.js Applications | article | Easy profiling for Node.js Applications |
| Debugging and profiling Node.js applications | tutorial | Four tools to improve the code quality and performance of your Node applications |
| Why is HTTP not secure? HTTP vs. HTTPS | article | HTTP vs. HTTPS: What are the differences? |
| 8 elements of securing Node.js applications | article | This article covers eight key elements of building security into your software development process to make your Node.js applications and modules robust |
| Alternative Package Managers For Node.js | article | Alternative Package Managers For Node.js |
| Node Events Tutorial. Node.js Tutorials for Beginners | video | Node Events Tutorial. Node.js Tutorials for Beginners |
| Streams and Buffers in Node.js | article | Streams and Buffers in Node.js |
| Node.js Stream api Documentation | documentation | Node.js Stream documentation |
| Node.js FS api Documentation | documentation | Node.js FS documentation |
| Error handling in Node.js | article | Error handling in Node.js |
| Node.js logging best practices | article | Node.js logging best practices: The essential guide |
| How to Write Tests for Node.js | article | How to Write Tests for Node.js |
- Create a docker compose file
- any type DB
- tools to work with db: DataGrip(trial, license), Table Plus, DB Beaver, Compass(MongoDB)
- Create a node js app
- command line tool
- CSV -> JSON converter
- custom logger
- log to file
- log to console
- log levels
- error handling
- option to save in DB
- TCP socket server parser
- send args and config as message
- send a file path to start parsing
- add HTTP interface to parser
- upload the file via Postman
- 3rd party API integration
- command line tool
A strongly typed programming language that builds on JavaScript and brings valuable benefits:
- Better code quality: TypeScript provides developers with the ability to catch errors early on in the development process. This helps to reduce the likelihood of runtime errors and improves the overall reliability of the code.
- Enhanced code maintainability: With its strong typing system and support for interfaces, TypeScript can make code more maintainable and easier to refactor. This can be particularly helpful when working on large-scale projects or when collaborating with other developers.
- Enhanced productivity: TypeScript provides several features such as code completion, type checking, and refactoring support that can help to improve developer productivity.
- Overview
- Quick start
- compiler
- basic tsconfig
- IDE setup
- linter
- first .ts file
- Migrating from JavaScript
- Basic ts types
- Object types
- type vs interface
- Classes
- tsconfig
- Generics
- Utility Types
- Type guards
- Declaration Files
- JSDoc
- Migrate an existing project to TypeScript or initialize a new one.
- Make sure that linter and tsconfig are set up
- Make sure that compilation runs without errors
- Add types for environment variables.
- Improve classes using access modifiers and interface implementations.
- Create a Generic (for example
IRepository<T>) - Use a Utility Type
| Name | Type | Description |
|---|---|---|
| TypeScript for JavaScript Programmers | article | TypeScript overview |
| Typescript with VSCode | article | Setup TypeScript for VSCode |
| Typescript with WebStorm | article | Setup TypeScript for WebStorm |
| How to setup TypeScript projects in 2021 | article | |
| Migrating from JavaScript | tutorial | js => ts |
| Basic types | documentation | Everyday types |
| Object types | documentation | How to type objects |
| Type vs interface stackoverflow | stackoverflow | Difference between types and interfaces |
| Type vs interface playground | ts playground | Difference between types and interfaces |
| Classes | documentation | Classes in TypeScript |
| What is a tsconfig.json | documentation | tsconfig overview |
| The recommended base for a TSConfig | npm package | Recommended tsconfig |
| TSConfig Reference | documentation | Full tsconfig documentation |
| Generics | documentation | Creating custom types with Generics |
| Utility Types | documentation | Common type transformations |
| Using type predicates | documentation | User-defined type guards |
| Declaration Files | documentation | Definition files |
| JSDoc Reference | documentation | JSDoc + TypeScript |
| Extending js with types but with no bundling | github repo | Alternatives to full ts solution |
| Types // as Comments ECMAScript Proposal | article | \/ |
| ECMAScript proposal: Type Annotations | github repo | Possible js/ts future |
| Typed JavaScript? For real? The “type annotations” proposal and what it’s all about by Gil Tayar | video | /\ |
| Collection of TypeScript type challenges | github repo | Collection of TypeScript type challenges with online judge |
| TypeScript Compiler Internals | article | Understanding TypeScript compiler |
Nest.js is a powerful framework for building scalable and maintainable server-side applications with Node.js. Key features:
- TypeScript support: Nest.js is built on top of TypeScript, which brings type safety, better code organization, and easier debugging.
- Modularity: Nest.js promotes modular architecture, which makes it easier to manage and test large codebases.
- Scalability: Nest.js is designed to be scalable and supports microservice architecture, allowing to build complex applications that can handle high traffic.
- Extensibility: Nest.js is highly extensible and supports a variety of plugins and modules to help customize and enhance the application.
- Decorators
- Setup
- Modules
- Services
- Controllers
- Providers
- Pipes
- Guards
- Database integration
- Tests
- Security
- Authentication
- Authorization
- CORS
- Helmet
- Set up Nest.js
- Create domain model
- Create domain services
- Create application services including:
- CRUD
- Authentication and authorization
- Integration with external systems
- Validation
- Create infrastructure
- Storage (database, cache)
- Logger
- Create controllers
- Cover with tests
| Name | Type | Description |
|---|---|---|
| Nest.js overview | article | Introduction to Nest.js and philosophy |
| JavaScript decorators | article | JavaScript Decorators: What They Are and When to Use Them |
| TypeScript decorators | documentation | How to use decorators in TypeScript |
| First steps | documentation | Core fundamentals of Nest.js |
| Getting started with NestJS | article | First steps, controllers, services, modules |
| Modules | documentation | All about modules |
| Controllers | documentation | All about controllers |
| Providers | documentation | All about providers |
| Pipes | documentation | All about pipes |
| Guards | documentation | All about guards |
| Series: API with NestJS | tutorial | Full Nest.js tutorial |
| Setting up a PostgreSQL database with TypeORM | tutorial | |
| Setting up PostgreSQL and Prisma | tutorial | |
| Introduction to MongoDB | tutorial | |
| Working with PostgreSQL using raw SQL queries | tutorial | |
| Error handling and data validation | tutorial | |
| Looking into dependency injection and modules | tutorial | |
| Testing | documentation | Official documentation about testing |
| Writing unit tests | tutorial | |
| Running unit tests with CI/CD and GitHub Actions | tutorial | |
| Testing NestJS services with integration tests | tutorial | |
| Authentication | documentation | Official documentation about authentication |
| Authenticating users with bcrypt, Passport, JWT and cookies | tutorial | |
| Two-factor authentication | tutorial | |
| Server-side sessions | tutorial | |
| Authenticating users with Google | tutorial | |
| Authorization | documentation | Official documentation about authorization |
| Authorization with roles and claims | tutorial | |
| CORS | documentation | Official documentation about CORS |
| Exploring the idea of microservices | tutorial | |
| Nest.js Crash Course | videos | Quick introduction through a playlist of short videos |
Why is learning about architectures in backend development important?
-
Scalability: As your application grows and the number of users increases, you need to ensure that your backend architecture can handle the load. By learning about different architectures, you can choose the best one for your application and ensure that it can scale effectively.
-
Maintainability: A well-designed architecture can make it easier to maintain and update your code. By learning about different architectures, you can choose the one that is most appropriate for your application and make sure that it is maintainable in the long run.
-
Code organization: A good architecture can help you keep your code organized and structured. This makes it easier to understand and modify in the future.
-
Best practices: Learning about different architectures will expose you to best practices and design patterns that can help you write better code. This can also help you to avoid common pitfalls and mistakes in your code.
Overall, learning about different architectures in Node.js backend development will make you a more effective and valuable developer.
- Monolithic architecture
- Microservices architecture
- Layered pattern
- MV* pattern
- Event-Driven pattern
https://github.com/Sairyss/backend-best-practices
| Name | Type | Short Description | Priority | Estimation (h) |
|---|---|---|---|---|
| Guidelines for using architecture patterns | tutorial | Guidelines for using architecture patterns | 1 | 1 |
| Layered Architecture | article | Layered pattern description | 1 | 1 |
| Monolithic Architecture | article | Monolithic architecture description | 1 | 1 |
| Monolithic Architecture | article | Monolithic architecture description | 1 | 1 |
| Microservices Architecture | article | Microservices architecture description | 1 | 1 |
| Microservices Architecture | video | Microservices architecture description | 1 | 1 |
| Microservices Architecture | video | Microservices architecture description | 1 | 1 |
| Event Driven Architecture | article | Event-driven architecture description | 1 | 1 |
| Client-server | article | Client-server pattern description | 1 | 1 |
| A Guided Tour inside a clean architecture | article | A Guided Tour inside a clean architecture code base | 2 | 1 |
| Clean architecture for the rest of us | article | Clean architecture for the rest of us | 2 | 1 |
| Model-View-* | article | Model-View-Whatever | 2 | 1 |
| Model-View-* | video | Model-View-Whatever | 2 | 1 |
| Model-View-Controller | code | Model-View-Controller | 2 | 1 |
| Clean Architecture and Design | video | Clean Architecture and Design | 1 | 1 |
| Event Driven | video | Event Driven Architecture | 1 | 1 |
| Event Driven | code | Event Driven Architecture | 1 | 1 |
CI/CD stands for Continuous Integration/Continuous Delivery, which is a set of practices that involve automating the building, testing, and deployment of software applications. The goal of CI/CD is to enable rapid and frequent releases of software updates while maintaining the quality of the code.
In a CI/CD workflow, developers commit their code changes to a version control system, and the CI/CD pipeline automatically builds and tests the code. If the tests pass, the code is then deployed to a staging environment for further testing and feedback. Once the code is deemed ready, it is automatically deployed to production.
CI/CD offers several benefits to web developers, including:
- Faster and more frequent releases: With CI/CD, code changes can be deployed to production more frequently, enabling developers to deliver new features and fixes more quickly.
- Increased confidence in code quality: Automated testing ensures that code changes meet quality standards, reducing the risk of errors and bugs in production.
- Better collaboration and communication: By using a shared pipeline, developers can easily collaborate and communicate with each other, leading to better coordination and fewer errors.
- Improved productivity: By automating many of the time-consuming tasks involved in building and deploying software, CI/CD frees up developers to focus on writing code and delivering new features.
In summary, learning CI/CD is valuable for web developers as it can improve their productivity, code quality, and collaboration with their team. It also helps them deliver new features and updates faster and with greater confidence.
- Github Actions and practice
- Quality gates
- Tests integration
- Static analysis
- Container registry
- Deployments provider (will use Digitalocean for practise)
| Name | Type | Short Description |
|---|---|---|
| What is CI/CD | article | CI/CD explained |
| A curated list of awesome things related to GitHub Actions | tutorial | A curated list of awesome things related to GitHub Actions |
| Github Actions — Everything You Need to Know to Get Started | article | Github Actions— Everything You Need to Know to Get Started |
| Github Actions — tutorial | tutorial | Github actions tutorial |
| What are quality gates | article | Quality gates |
| Integration tests | article | Integration tests |
| Integration tests and practices | code | Integration tests |
| Static analysis | article | static analysis tests |
| Static analysis example, sonarqube | article | static analysis tests |
| Container registry | article | Registry |
| Container registry | article | Registry |
| Container registry, Docker CI/CD | tutorial | Docker CI/CD, registry |
| Popular cloud server providers | tutorial | Cloud server providers |