/node_modules

/build

node_modules/

build/

.docusaurus/

{

"arrowParens": "always",

"bracketSpacing": false,

"bracketSameLine": true,

"printWidth": 80,

"proseWrap": "never",

"singleQuote": true,

"trailingComma": "all"

}

This website is built using [Docusaurus](https://docusaurus.io/), a modern static website generator.

yarn

yarn start

This command starts a local development server and opens up a browser window. Most changes are reflected live without having to restart the server.

yarn build

This command generates static content into the `build` directory and can be served using any static contents hosting service.

Using SSH:

USE_SSH=true yarn deploy

Not using SSH:

GIT_USER=<Your GitHub username> yarn deploy

If you are using GitHub pages for hosting, this command is a convenient way to build the website and push to the `gh-pages` branch.

You know about CI/CD pipelines, but your current team does manual deployments. One person runs tests, builds the app, and pushes to production. It's slow but manageable for your small team. But as teams grow and deployment frequency increases, manual processes become too difficult and lead to mistakes. You realize that while manual deployments work for small teams, most professional environments expect automated pipelines.

Backend developers especially benefit from mastering CI/CD since they often manage server deployments, database migrations, and infrastructure changes. However, understanding these concepts helps all developers work more effectively in team environments. It's time to embrace CI/CD.

- **Continuous Integration (CI):** The practice of regularly merging code changes into a shared repository, typically the main branch. Each merge triggers an automated build and test process to identify integration issues early.

- **Continuous Delivery (CD):** The practice of automatically preparing code for release after successful integration. This includes packaging the application, deploying to a staging environment, and running additional tests to ensure the build is always production-ready.

- **Continuous Deployment (also CD):** The practice of automatically deploying code to production once it passes all previous stages. No manual intervention is required.

Owning your part in CI/CD isn't just about following company processes — it directly improves your day-to-day experience.

- **Faster Feedback:** Your pipeline alerts you within minutes if something breaks, helping you catch issues early instead of finding out hours (or worse, days) later.

- **Less Risk, Less Stress:** Automated deployments take the pressure off "release day" and remove the chance of last-minute mistakes.

- **Real Ownership:** With the "you build it, you run it" mindset, you get to see how your code behaves in the real world — and you gain more control over the quality of what you deliver.

CI/CD isn't a box to check. It's a workflow that helps you and your team build and ship better software, faster. The more you understand your role in it, the more confident and capable you become.

You don't have to be an expert in CI/CD, but you should be able to understand the basics and be able to use the tools. The goal is to be comfortable with the fundamental concepts and workflows that enable your team to deploy safely and efficiently.

This is where you have the most direct impact. Your main goal is to ensure the `main` branch is always stable and green.

- **Fixing the Build is Priority #1:** If your commit breaks the build in the `main` branch, you have broken it for _everyone_. Drop what you're doing. Fixing the build is now your most important task. A broken pipeline blocks the entire team from delivering value.

- **Your Tests are the Pipeline's Backbone:** The pipeline relies entirely on your unit and integration tests to validate your changes. If your tests are unreliable or incomplete, the pipeline provides a false sense of security. Quality tests are a requirement for effective CI.

- **Commit Small and Often:** Large pull requests are a nightmare for CI. They are difficult to review, and if they break the build, it's hard to find the cause. Small commits that represent a single logical change make the process smoother and debugging easier.

- **Understand Your Service's Build Process:** You don't need to be an expert, but you should understand how your application is built, tested, and packaged. Know where your dependencies are defined (`pom.xml`, `package.json`) and how to run the build script locally to diagnose issues.

Your responsibility extends beyond just passing tests. You need to write code that can be deployed and operated safely and automatically.

- **Embrace Feature Flags:** Feature flags (or feature toggles) allow you to deploy code to production without releasing it to users. This separates deployment from release, greatly reducing the risk of a new feature causing an outage. Merging dark code is a standard, expected practice.

- **Write Deployment-Ready Code:** Your code should be ready to deploy at any time. This means:

- **Configuration Management:** Use environment variables for configuration, not hardcoded values.

- **Database Migrations:** Write backward-compatible database changes that can be deployed without downtime.

- **Graceful Shutdowns:** Handle termination signals properly so your application can shut down cleanly during deployments.

- **Monitor Your Deployments:** You're responsible for knowing if your deployment succeeded or failed. Learn to read deployment logs and understand the metrics that matter for your application. For more information about monitoring and observability, see the [Observability](./observability.md) section.

If you're new to CI/CD, begin with something easy like [GitHub Actions](https://github.com/features/actions). It combines both CI and CD in one place, making it simpler to understand without needing many tools. You can create basic setups that test your code and put it online on simple platforms. As you get more comfortable, you can add more advanced features.

- [🎥 What is Continuous Integration?](https://youtu.be/1er2cjUq1UI?si=Rqc8pEP4wqV1l8US)

- [🎥 What is Continuous Delivery?](https://youtu.be/2TTU5BB-k9U?si=LTpV3mEZdiHtXOfg)

- [🎥 What are Feature Flags?](https://youtu.be/AJa2B-twtG4?si=6yMfLVnIZdUIeJyJ)

- [🎥 CI/CD Explained: The DevOps Skill That Makes You 10x More Valuable](https://youtu.be/AknbizcLq4w?si=wL8jrOa-ygigDNfr)

- [🎥 Deployment Pipelines](https://youtube.com/playlist?list=PLwLLcwQlnXBzhxIXSbtDPX78zYTgvST0B&si=JEi_UGWOvRIjAtU_)

- [📚 GitLab CI/CD Documentation](https://about.gitlab.com/topics/ci-cd/)

- [📚 What is CI/CD? by Github](https://github.com/resources/articles/devops/ci-cd)

- [🎥 GitLab CI/CD from zero to hero (Arabic)](https://youtu.be/S-kpjjeDZGw?si=9IuyOqulI3BQqZoy)

- [🎥 GitHub Actions full course Arabic](https://youtu.be/7gJFHjXscr8?si=JXHkVi82At4UO27q)

- [🎥 شرح مفصل (CI/CD) Continuous Integration و continuous delivery و continuous deployment](https://youtu.be/l_ih7lVHBII?si=dXTSeLXWujCtJ3fu)

- [🎥 ما هو التكامل المستمر والنشر المستمر CI/CD](https://youtu.be/hFzSG9qNWWs?si=D2QAfu9NEgfy5hnq)

- [🎥 أكاديمية ترميز - CI/CD](https://youtu.be/XdaW-gVzsXo?si=xsjUUngAX9_Vu5pU)

- [📚 مقالات اقرأ-تك](https://eqraatech.com/tag/ci-cd/)

You've heard about Docker and containers, but your current setup is simple—you develop locally and deploy to a single server that the DevOps person manages. It works fine for your current project. But as soon as you need to scale, work with multiple environments, or collaborate with larger teams, environment consistency becomes important. You realize that while you can avoid containers in simple environments, most modern development teams use them. It's time to learn containerization.

By solving the environment problem, containers provide powerful advantages that improve the entire software development process. For you and your team, this translates to real benefits:

- **Consistency and Reliability:** The container creates a single source of truth for your application's environment. This removes the "it works on my machine" problem, leading to fewer bugs and more reliable deployments.

- **True Portability:** A container built on your laptop will run the same way on a testing server, a production server, or any cloud provider (AWS, Azure, Google Cloud). You can move your application without changing its code or configuration.

- **Efficiency and Scalability:** Containers are lightweight and start up quickly because they share the host machine's OS kernel. This allows you to run more containers on the same hardware compared to VMs, making it easier and cheaper to scale your application up or down based on demand.

- **Simplified Collaboration:** When your entire team uses the same containerized environment, everyone—from developers to QA testers—is on the same page. This reduces friction and time wasted on environment setup and debugging.

As a modern developer, you should be comfortable with the basic concepts of containerization. This doesn't mean you need to be a DevOps expert, but you should understand how to package your own applications into containers and how to run them. The goal is to be able to create a reliable and portable version of your software that can be handed off for deployment or used in a larger automated workflow.

While other containerization tools exist (like Podman), **[Docker](https://www.docker.com/)** has become the most popular industry standard. Its widespread adoption means you'll see it everywhere in tutorials, open-source projects, and job requirements. Learning Docker is your most important first step into the world of containers.

- **Dockerfile**: This is a simple text file you create that acts as a blueprint for your container. It lists all the instructions needed to build your application's environment, such as specifying a base OS, copying your code, installing dependencies, and defining the startup command.

- **Image and Container**: Using the `Dockerfile`, you build an **Image**, which is a small, independent, and runnable package. When you run an Image, it becomes a **Container**—an active, running version of your application.

- **Core Commands**: You'll need to get comfortable with a few essential commands to build images from your Dockerfile, run containers from those images, and list which containers are currently active.

- **Docker Compose**: For applications that require multiple services to run at once (like a backend API, a database, and a frontend), you will use **[Docker Compose](https://docs.docker.com/compose/)**. It lets you define and manage your entire multi-container application with a single YAML configuration file.

While building and running containers on your own machine is a skill for every developer, managing them in a live production environment is primarily a task for backend and DevOps engineers. However, understanding the core concepts of **container orchestration** is valuable for everyone on a development team. It helps you understand how your application will ultimately be deployed, scaled, and maintained.

Orchestration tools become necessary when you move beyond running a few containers on a single machine. They solve the complex problem of managing maybe hundreds or thousands of containers across many servers. These tools automate the deployment, management, scaling, and networking of your applications. The most popular orchestration tool today is **[Kubernetes (K8s)](https://kubernetes.io/)**. Kubernetes groups containers into logical units called **Pods** and manages their lifecycle automatically. It handles complex tasks like:

- **Service Discovery & Load Balancing:** Distributing network traffic to ensure your application is stable.

- **Automated Rollouts & Rollbacks:** Slowly deploying new versions of your app and rolling back if something goes wrong.

- **Self-Healing:** Restarting containers that fail, replacing them, and killing containers that don't respond to health checks.

While you aren't expected to be a Kubernetes administrator, you should understand its basic concepts (like Pods, Services, and Deployments). This knowledge is important when working with cloud platforms like AWS, Google Cloud, or Azure, as they all offer managed Kubernetes services (EKS, GKE, AKS) that simplify its setup and operation.

For simpler use cases, **[Docker Swarm](https://docs.docker.com/engine/swarm/)** is an easier-to-learn alternative that is built into Docker itself. It offers basic orchestration features and is a good first step before diving into the complexities of Kubernetes.

- [🎥 Containerization Explained](https://youtu.be/0qotVMX-J5s?si=bujRV-XPYrP90PXo)

- [🎥 Virtual Machine (VM) vs Docker](https://youtu.be/a1M_thDTqmU?si=Ea-jIGFbzPFQyHHi)

- [🎥 Kubernetes vs. Docker: It's Not an Either/Or Question](https://youtu.be/2vMEQ5zs1ko?si=nn2Q5rSq8c8a4apb)

- [🎥 Docker Tutorial for Beginners](https://youtube.com/playlist?list=PLy7NrYWoggjzfAHlUusx2wuDwfCrmJYcs&si=WgrtQworBys__gfT)

- [🎥 Container Orchestration Explained](https://youtu.be/kBF6Bvth0zw?si=QQ1udy7DhjE9kWGm)

- [🎥 Complete Kubernetes Tutorial for Beginners](https://youtube.com/playlist?list=PLy7NrYWoggjziYQIDorlXjTvvwweTYoNC&si=wH7baSjI0icY6mLK)

- [🎥 قصة الكونتينر .. Container story](https://youtu.be/jPzJVH1ab-4?si=qr0UIRRSrld8RVnQ)

- [🎥 Docker Crash Course - كورس Docker للمبتدئين](https://youtu.be/9yoe8dBvAZ0?si=TSTdBGCoqOob5ZIz)

- [🎥Docker سلسلة تعلم - by Codographia](https://youtube.com/playlist?list=PLX1bW_GeBRhDkTf_jbdvBbkHs2LCWVeXZ&si=WzaUxanOe8awl1aZ)

- [🎥 Kubernetes بالعربي](https://youtu.be/7gJFHjXscr8?si=JXHkVi82At4UO27q)

- [🎥 Kubernetes 101](https://youtu.be/KYhcpHIrjtE?si=uKH9vL4M2NyToPsr)

- **[📚 مقالات اقرأ-تك](https://eqraatech.com/tag/docker/)**

sidebar_position: 1

slug: /

Dev Rebase is a collection of short guides designed to help developers learn about modern software development practices. These guides cover essential topics that are commonly expected in today's tech industry, especially when working at international companies or applying for remote positions.

I'm [Mohammad Ghanem](https://www.linkedin.com/in/ghanem-mhd/), a software engineer who moved from Syria to Germany. As someone from Syria, I experienced firsthand how software development practices can vary significantly between different regions and markets...

This became very clear when I moved to Germany and started working at different companies. I quickly realized there were many practices and approaches that most companies expected me to know as a developer. I had to actively learn these topics to bridge the gap in my knowledge and meet industry standards.

About a year ago, I started volunteering with the [Imagine Foundation](https://www.joinimagine.com/) as a technical coach. I began conducting technical coaching sessions for developers who were trying to enter the European job market. Over the course of this work, I completed dozens of sessions, numbering in the high double digits, with people at different skill levels.

I loved every single session and had the pleasure of meeting many wonderful people. During these sessions, I noticed that most fellows (we call them fellows because that's the name of the program at Imagine) faced similar knowledge gaps. This happened for the same reasons I experienced - their work environments implemented fewer modern practices, and the expectations were lower.

This gap in knowledge and skills could affect their chances when applying for remote jobs or positions that require relocation. After seeing this pattern repeat many times, I realized it would be valuable to collect these practices and topics in one place and share them with my fellows and anyone else who might find them useful.

This guide is **not** a roadmap to learn programming or start in the tech world. Instead, it targets:

- Developers who already know how to program.

- Computer Science graduates with programming knowledge.

- People already working in the industry as frontend, backend, or mobile engineers.

- Anyone looking to understand modern development practices used in international companies.

If you can already program and build applications, but want to learn about industry practices, tools, and methodologies, this guide is for you.

The topics are presented in an order that makes logical sense, but **you can read them in any order** that works for you. Each guide is designed to be self-contained, so feel free to jump to topics that interest you most or that you need to learn for your current work. At the end of each topic, there a list of resources in English and Arabic. These resources are not exhaustive and don't the topic in depth, but they are a good starting point to learn more.

**Core Skills** - Essential technical skills that every developer needs to work effectively in modern development environments.

- [Web Development](/web)

- [Git](/git)

- [Testing](/testing)

**Deployment & Production** - Tools and practices for deploying applications and maintaining them in production environments.

- [Containerization](/containerization)

- [CI/CD](/ci-cd)

- [Observability](/observability)

**Learn by Doing** - Practical ways to apply your skills and build real-world experience while contributing to the developer community.

- [Open Source](/open-source)

**Learn from Others** - Resources for connecting with experienced developers and communities that can accelerate your growth.

- [Mentorship](/mentorship)

- [Global Communities](/global-communities)

This is an open source project, and **anyone is welcome to contribute**! If you find a topic that is missing, contains errors, or could be improved, please feel free to open an issue or submit a pull request at [dev-rebase/dev-rebase.github.io](https://github.com/dev-rebase/dev-rebase.github.io). Also, if there's a specific topic you'd like to see part of this guide, please create an issue to request it.