SAP Fiori Elements — Part 12: Understanding Git in SAP BTP in Simple Words

Why Modern SAP Developers Cannot Live Without Git

Imagine five students are working together on one school project.

One student edits page 1.

Another edits page 3.

Someone fixes spelling mistakes.

Another person adds new pictures.

Now imagine everyone saves their own version with names like:

• Final_Project_v1
• Final_Project_v2
• Final_Project_Final
• Final_Project_Real_Final
• Final_Project_Last_Final_2

Very quickly, everything becomes chaos.

Questions start appearing:

“Who changed this?”

“Which file is latest?”

“How do we restore yesterday’s version?”

“Why did someone overwrite my work?”

Sounds painful, right?

This exact problem happens in software development too.

And that is where Git enters the picture.

Think of Git as a smart history manager and teamwork coordinator for your code.

What Is Git?

In simple words:

Git is a version control system that tracks changes in your code and allows multiple developers to work together safely.

Git remembers:

✔ What changed ✔ Who changed it ✔ When it changed ✔ Why it changed

Instead of losing work or creating hundreds of files with different names, Git keeps everything organized.

Why Do SAP Developers Need Git?

Many SAP developers already know something called:

Transport Management System (TMS)

TMS also allows moving changes between systems and restoring previous versions.

So naturally beginners ask:

“If TMS already exists, why use Git?”

Let’s understand this using a simple example.

Imagine a single ABAP program.

With traditional development:

Developer A starts working.

Developer B wants to make changes too.

Problem:

The object often becomes locked.

Developer B waits.

Developer C waits.

Everyone waits.

Not very productive.

Git solves this differently.

Git’s Superpower: Branches

Think of the main application as a big road.

Now imagine creating small side roads where developers can safely experiment.

Those side roads are called:

Branches

Each developer can:

✔ Build new features ✔ Fix bugs ✔ Test changes

without disturbing the original application.

After everything works correctly:

The changes return safely to the main road.

Understanding Branches With a Real-Life Example

Suppose you own an online shopping application.

The current application works perfectly.

Now your team receives two requests:

Developer A:

“I want to add dark mode.”

Developer B:

“I need to fix payment issues.”

Without Git:

Both developers may accidentally affect each other.

With Git:

Main Branch

↓

Feature Branch A → Dark Mode

Feature Branch B → Payment Fix

↓

Testing

↓

Merge back into Main Branch

Everyone works peacefully.

Local Repository vs Remote Repository

This confuses almost every beginner.

Let’s simplify it.

Local Repository

This exists inside your own development environment.

Think of it as your notebook on your desk.

You make changes here first.

Remote Repository

Remote repositories usually live in:

• GitHub
• GitLab

Think of this as cloud storage for the entire team.

Benefits:

✔ Backup safety ✔ Team collaboration ✔ Shared access

The Four Important Git Actions

These four words appear everywhere.

Let’s make them easy.

Stage

You select files that are ready to save.

Think of it as:

“I want these specific changes included.”

Commit

Commit creates a snapshot of your work.

Think of taking a photo of your project at a particular moment.

Example:

“Added Product Filters”

“Fixed Login Error”

Push

Push sends your local work to GitHub.

Think:

Laptop → Cloud

Pull

Pull brings the latest changes from GitHub.

Think:

Cloud → Laptop

Complete Git Workflow in SAP BTP

Here is the overall process developers commonly follow.

Step 1:

Create a repository in GitHub.

↓

Step 2:

Open the project in SAP BTP.

↓

Step 3:

Initialize Git repository.

↓

Step 4:

Connect local project with GitHub.

↓

Step 5:

Stage files.

↓

Step 6:

Commit changes.

↓

Step 7:

Push changes to remote repository.

↓

Step 8:

Create feature branch.

↓

Step 9:

Develop new functionality.

↓

Step 10:

Create Pull Request.

↓

Step 11:

Merge into Main branch.

↓

Step 12:

Pull latest changes.

What Is a Pull Request?

Think of a Pull Request like asking permission.

A developer says:

“I made these changes. Please review them before adding them to the main application.”

Team members can:

✔ Review code ✔ Suggest improvements ✔ Approve changes

Only then do the changes enter the main branch.

This keeps applications stable.

Why Branch Protection Matters

Imagine somebody accidentally changing production code directly.

Disaster.

GitHub provides something called:

Branch Protection Rules

These rules prevent:

❌ Direct modifications to main branch ❌ Accidental deletion ❌ Unauthorized changes

Developers are forced to use safer workflows.

Why Git Is Becoming Important in SAP

SAP development is evolving rapidly.

Traditional approaches are slowly moving toward:

• Cloud development
• DevOps
• Continuous Integration
• Git-based workflows

Git gives developers:

✔ Better collaboration ✔ Safer development ✔ Easy rollback ✔ Version history ✔ Team productivity

This is why modern SAP developers are expected to know Git.

Final Thoughts

When beginners hear terms like:

• Repository
• Commit
• Push
• Pull
• Branches
• Pull Requests

everything sounds complicated.

But at its heart, Git is simply a smart system that answers one question:

“How can multiple people work on the same project without creating chaos?”

Once you understand that idea, the terminology becomes much easier.

In the next part, we’ll move deeper into advanced Git concepts and understand conflict handling, commit strategies, and modern SAP development workflows.

Happy learning 🚀