Backend Burger

1- CI/CD pipeline (anyone):

a- Jenkins b- Azure c- Circle CI
2- Containerization (anyone):
a- Docker
3- Architectural patterns (all):
a- Monolithic b- Microservices c- Serverless
d- CQRS
4- Testing (all):
a- Unit testing b- Functional testing c- Integration testing
5- Caching (all):
a- Server-side b- CDN c- Redis
d- Client-side
1) CI/CD pipeline:
It stands for Continuous Integration and Continuous Delivery or Deployment. A CI/CD pipeline is a
process or workflow that automates the process of building, deploying and testing web or mobile applications to
reduce the error rate and increase delivery speed. Because of its continuous feedback system, it also increases
consistency and reliability.
Tools for CI/CD pipeline:
a- Building:
- Maven - Gradle - npm
b- Deploying:
- Helm - Terraform - Ansible
- Chef - Puppet
c- Testing:
- Postman for API - PyTest for python - Junit for Java
- Mocha for JavaScript
d- Containerization:
- Docker
e- CI/CD tools:
- Jenkins - Azure - Circle CI
- GitLab
f- VCS:
- Git & GitHub
2) Containerization:
It is a lightweight form of virtualization that involves packaging an application along with all of its
dependencies, libraries and configurations into a single unit called container. Containers can run on all systems
because they contain everything needed to execute the application. Docker is the most common example of it.
Tools for containerization:
Docker:
It is most commonly used tool for containerization.
Some important terms of docker are:
a- Docker-image:
b- Docker-container:
c- Docker-hub:
 Some important commands of docker are:
- docker version: To check the version of docker
- docker pull node: To pull built-in docker-image (like node, ubuntu, etc.)
- docker run hello world: To download and pull a new image named hello world
- docker p: To list out all the running containers
- docker ps -a: It will display the names and other details of docker images/containers
3) Architectural patterns:
a- Monolithic:
- An architecture in which front-end, back-end and database all are made and deployed in a single unit is
called monolithic.
- It has single CI/CD pipeline.
- It is easier to understand because all the files are present at a single place.
- If one module destroys, the whole system will be destroyed and if we have to made update in one module,
then we have to made changes in all others according to it.
- Django, shopify, oracle, etc uses this architecture.
b- Microservices:
- An architecture in which front-end, back-end and database are build and deployed independently and
regarded as separate units is called microservices.
- Each unit has own CI/CD pipeline.
- Independent deployment using different technologies (languages & frameworks) makes it scalable and
flexible to use.
- Complex to develop, management overhead, high infra costs.
- Netflix, amazon, Spotify, Airbnb, etc use this architecture.
Note:
Each microservice interact with others through:
o API calls (synchronous communication)
o Message brokers (asynchronous communication)
c- Serverless architecture:
- An architecture in which developer don’t have to manage server is called serverless architecture.
- Cost-effective, auto-scaling, easy to use, etc
- Less control of developer
- AWS, Azure, google, etc provides this architecture.
d- CQRS:
- It stands for command query responsibility segregation. An architecture which separates read and write
operations for the data model. Commands update write data while queries read data.
- Optimize read and write capabilities.
- Increased complexity, complex synchronization b/w models of read and write.
- Linkdin, Microsoft etc, uses this architecture.

Difference:

Non-serverless architecture Serverless architecture

Developer has to manage server manually Developer don’t have to manage server manually
Manual scaling (RAM, storage, others) Automatic scaling
Pay per-hour Pay per-invoke (Cost-effective)

4) Testing:
a- Unit-Testing:
Tests the whole code or some part it like some tools are PyTest for python testing, test for
JavaScript testing etc.
b- Integration-Testing:
It checks the integration points are either integrated successfully or not module-to-
module, package-to-package, frontend-to-backend etc.
c- Functional-Testing:
It checks either the application is working fine according to the requirements or not
means it checks the functionality of the application.