How I built my portfolio website


# How I Built My Portfolio Website

## Introduction

As a QA developer transitioning deeper into automation and development, I realized I needed a strong personal portfolio—not just to showcase my work, but to demonstrate my practical skills. Instead of using a no-code builder, I decided to build my portfolio site from scratch to challenge myself and learn along the way.

This article walks through my process, decisions, and lessons learned.

---

## Why I Decided to Build My Own Portfolio

I had three main goals:

* Showcase my **QA and automation projects**
* Demonstrate **real development skills**
* Create something I can **continuously improve**

Using templates would have been faster, but building it myself gave me hands-on experience—which is how I learn best.

---

## Planning the Portfolio

Before writing any code, I outlined what I actually needed:

### Core Sections

* Home (Introduction + personal branding)
* About Me
* Projects
* Skills
* Contact

### Key Considerations

* Clean and minimal design
* Fast loading speed
* Mobile responsiveness
* Easy to update later

---

## Choosing the Tech Stack

I intentionally kept things simple:

* **HTML** – Structure
* **CSS** – Styling
* **JavaScript** – Interactivity
* **GitHub Pages / Vercel** – Deployment

I avoided heavy frameworks at first because I wanted to fully understand the fundamentals.

---

## Building the UI

### Step 1: Layout

I started with a basic layout:

* Header (navigation)
* Main content sections
* Footer

I used Flexbox and Grid to structure the layout.

### Step 2: Styling

I focused on:

* Neutral color palette
* Consistent spacing
* Readable typography

I also made sure the design looks clean on both desktop and mobile.

---

## Showcasing My Projects

This was the most important section.

For each project, I included:

* Project title
* Short description
* Tech stack used
* GitHub/demo link

Since I work in QA, I made sure to highlight:

* Test automation scripts
* Bug reports
* Real-world testing scenarios

---

## Adding Interactivity

To make the site feel modern, I added:

* Smooth scrolling
* Hover effects
* Simple animations

Nothing too complex—just enough to improve user experience.

---

## Deployment

Once the site was ready, I deployed it.

### Steps I followed:

1. Pushed code to GitHub
2. Connected repository to deployment platform
3. Configured domain (optional)
4. Tested live version

Deployment was surprisingly smooth and fast.

---

## Challenges I Faced

### 1. Design Decisions

I spent more time than expected deciding how things should look.

**Lesson:** Start simple, iterate later.

### 2. Responsiveness

Making the site look good on all screen sizes took effort.

**Lesson:** Always design mobile-first.

### 3. Overthinking Features

I initially wanted too many features.

**Lesson:** Focus on what actually matters—clarity and usability.

---

## What I Learned

Building this portfolio helped me:

* Strengthen my frontend fundamentals
* Think like a developer, not just a tester
* Understand deployment workflows
* Improve my problem-solving skills

Most importantly, it gave me confidence.

---

## What I’d Improve Next

* Add a blog section
* Integrate real project case studies
* Improve UI/UX with better animations
* Add analytics to track visitors

---

## Final Thoughts

Building my own portfolio was one of the best decisions I made for my career. It’s more than just a website—it’s proof of my skills and growth.

If you're in QA or transitioning into development, I highly recommend building your own portfolio from scratch. It teaches you far more than any tutorial ever will.

---

## Bonus Tip

Don’t wait until you’re “ready.” Start building, and improve as you go.

That’s where the real learning happens.


How to use Git effectively

# How to Use Git Effectively

## Introduction

Git is more than just a version control system—it’s a critical tool for managing code, collaborating with teams, and maintaining a clean development workflow. Many developers use Git daily, but not everyone uses it effectively.

This article focuses on practical strategies to use Git in a structured, efficient, and professional way.

---

## Core Principles of Effective Git Usage

Before diving into commands, it’s important to understand a few key principles:

* **Atomic commits**: Each commit should represent one logical change
* **Clear history**: Your commit history should be easy to read and understand
* **Safe experimentation**: Use branches to avoid breaking stable code
* **Consistency**: Follow a standard workflow across projects

---

## Structuring Your Workflow

A clean Git workflow typically revolves around branches.

### Common Branch Strategy

* `main` → Production-ready code
* `develop` → Integration branch (optional for small projects)
* `feature/*` → New features
* `bugfix/*` → Bug fixes
* `hotfix/*` → Urgent production fixes

### Example

```bash
git checkout -b feature/login-api
```

This ensures your work is isolated and does not affect stable code.

---

## Writing Meaningful Commit Messages

Poor commit messages make debugging and collaboration difficult.

### Bad Example

```bash
git commit -m "fixed stuff"
```

### Good Example

```bash
git commit -m "Fix login API timeout issue by increasing request timeout to 10s"
```

### Recommended Format

```
<type>: <short description>

[optional body]
```

Common types:

* `feat` – new feature
* `fix` – bug fix
* `refactor` – code improvement
* `test` – test-related changes
* `docs` – documentation

---

## Committing Strategically

Avoid large, messy commits.

### Best Practices

* Commit frequently, but with purpose
* Stage only relevant changes:

```bash
git add specific-file.js
```

* Use interactive staging:

```bash
git add -p
```

This allows you to split changes into logical chunks.

---

## Using Branches Properly

Branches are essential for safe development.

### Key Practices

* Never work directly on `main`
* Keep branches short-lived
* Regularly sync with the base branch

```bash
git pull origin main
```

---

## Rebasing vs Merging

Understanding this distinction is critical.

### Merge

```bash
git merge feature/login-api
```

* Preserves history
* Adds merge commits

### Rebase

```bash
git rebase main
```

* Creates a cleaner, linear history
* Rewrites commit history

### When to Use

* Use **merge** for shared/public branches
* Use **rebase** for local cleanup before merging

---

## Keeping History Clean

A messy Git history makes debugging harder.

### Squashing Commits

Before merging:

```bash
git rebase -i HEAD~3
```

This allows you to combine multiple commits into one.

---

## Handling Mistakes Safely

Mistakes are inevitable. Git provides ways to recover.

### Undo Last Commit (Keep Changes)

```bash
git reset --soft HEAD~1
```

### Discard Changes

```bash
git checkout -- file.js
```

### Revert a Commit

```bash
git revert <commit-hash>
```

---

## Using Git for Collaboration

When working in a team:

### Pull Requests (PRs)

* Keep PRs small and focused
* Add clear descriptions
* Link related issues

### Code Reviews

* Review for logic, not just syntax
* Provide actionable feedback

---

## Automating with Git Hooks (Advanced)

Git hooks can enforce quality.

Examples:

* Prevent commits without proper messages
* Run tests before pushing

Example pre-commit hook:

```bash
#!/bin/sh
npm test
```

---

## Common Mistakes to Avoid

* Committing unnecessary files (e.g., `node_modules`)
* Working on `main` directly
* Writing vague commit messages
* Ignoring `.gitignore`
* Pushing broken code

---

## Practical Workflow Example

```bash
# Create branch
git checkout -b feature/payment-integration

# Work and commit
git add .
git commit -m "feat: add Stripe payment integration"

# Sync with main
git pull origin main --rebase

# Push branch
git push origin feature/payment-integration
```

---

## What Effective Git Usage Gives You

* Cleaner project history
* Easier debugging
* Better team collaboration
* Safer experimentation
* Professional development workflow

---

## Final Thoughts

Git is a tool that rewards discipline. Small improvements in how you use Git can significantly impact your productivity and code quality.

Treat your Git history as documentation. Future you—and your teammates—will rely on it.

---

## Bonus Tip

If you're unsure about a command, create a test repository and experiment. Learning Git safely is just as important as using it effectively.


Tinkering with AOSP


# Title: From Fastboot to Flawless Code: A Programmer's Journey with AOSP Custom Builds

**Introduction**

Every programmer's journey has a unique beginning, a spark that ignites a passion for coding and problem-solving. For me, that journey began in the 10th grade with a curious mind, an Android Open Source Project (AOSP), and a command line. This article takes you through the inspiring journey of a programmer (me) who started by troubleshooting and debugging AOSP custom builds, delving deep into the world of shell commands and system interactions in the fastboot mode.

**The Humble Beginnings**

It was during the 10th grade when I was introduced to the world of Android customization and open-source development. Armed with an insatiable curiosity and a desire to tinker with technology, I embarked on a journey that would shape my programming skills for years to come. The first step involved navigating the Android Open Source Project (AOSP), a massive codebase that powers the Android operating system.

**The World of Troubleshooting and Debugging**

Customization often comes hand in hand with troubleshooting, and AOSP was no exception. I had soon found themselves knee-deep in debugging sessions, deciphering cryptic error messages, and unraveling the intricacies of the Android system. From mismatched dependencies to elusive memory leaks, each roadblock presented an opportunity to learn and grow.

**Mastering the Art of Shell Commands**

One of the key tools in my arsenal was the command line interface. Shell commands became my trusted companions, enabling me to interact with the system in ways that a graphical interface couldn't provide. Fastboot mode, a protocol used to re-flash partitions on an Android device, became a playground for experimentation. Through trial and error, I had discovered the power of shell commands in controlling and manipulating the device's internals.

**Embracing the Learning Curve**

The journey wasn't without its challenges. The learning curve was steep, and there were moments of frustration and self-doubt. But these challenges were met with resilience and a hunger for knowledge. Online forums, documentation, and the developer community provided invaluable support and guidance, turning every stumbling block into a stepping stone.

**Evolution of Skills**

As time went on, my skills evolved. What started as simple troubleshooting gradually transformed into contributing to the AOSP codebase. From bug fixes to feature enhancements, they left their mark on the project, all while continuing to refine their understanding of the Android ecosystem.

**Lessons Learned**

1. **Persistence Pays Off:** The journey from a novice to an experienced programmer is not always easy. Perseverance and the willingness to learn from failures are key.

2. **Community Matters:** The programming community is a valuable resource. Engaging with like-minded individuals, sharing experiences, and seeking help can accelerate your growth.

3. **Hands-On Learning:** Real-world projects and hands-on experience are often the best teachers. Don't shy away from experimenting and diving into complex projects.

4. **Mistakes are Stepping Stones:** Mistakes are inevitable, especially in programming. Each mistake is an opportunity to learn and improve.

5. **Passion Drives Progress:** A genuine passion for what you're doing fuels your progress. The enthusiasm to solve problems and create something unique is a powerful driving force.

**Conclusion**

From navigating the intricacies of AOSP to mastering shell commands in fastboot mode, my journey is a testament to the transformative power of curiosity and determination. Starting with troubleshooting and debugging, I evolved into a seasoned developer who not only understood the Android system but also left their mark on it. This journey reminds us that every programmer's path is unique, filled with challenges that shape them into the capable individuals they become. So, whether you're just starting or have been on this path for years, remember that your journey is a valuable part of your growth as a programmer.



Welcome to my blog!