Web Development
79.3K subscribers
1.39K photos
1 video
2 files
738 links
Learn Web Development From Scratch

0️⃣ HTML / CSS
1️⃣ JavaScript
2️⃣ React / Vue / Angular
3️⃣ Node.js / Express
4️⃣ REST API
5️⃣ SQL / NoSQL Databases
6️⃣ UI / UX Design
7️⃣ Git / GitHub

Admin: @love_data
Download Telegram
🌐 Web Development Roadmap — Part 5

🖥️ What Is a Web Server?

A web server is a system that receives requests from clients, processes them, and sends web content or data back.

In simple terms:



A web server receives a request and provides the requested website or resource.



Remember the basic flow:

Browser

↓

Request

↓

Web Server

↓

Response

↓

Browser

🧩 What Does a Web Server Do?

A web server mainly performs three important tasks.

1️⃣ Receives Requests

When you open a website, your browser sends a request.

For example:

Browser

↓

"Give me the homepage"

↓

Web Server

2️⃣ Processes the Request

The server determines what needs to be returned.

For a simple website, it might find an HTML file.

For a web application, it might need to:

Receive request

↓

Run application logic

↓

Check database

↓

Prepare result

3️⃣ Sends a Response

The server sends something back to the browser.

It could be:

HTML

CSS

JavaScript

Images

JSON data

Other files

For example:

Server

↓

HTML + CSS + JavaScript

↓

Browser

📁 Static Website Example

Suppose a server has these files:

website/
│
├── index.html
├── style.css
├── script.js
└── logo.png


When someone requests the homepage, the server can send these resources to the browser.

The browser then uses them to display the website.

⚙️ Dynamic Website Example

Now imagine an online shopping application.

You request:

/product/123

The server might:

Browser

↓

Request product 123

↓

Server

↓

Check application logic

↓

Database

↓

Find product 123

↓

Server prepares response

↓

Browser

The response could contain information such as:

Product name

Price

Description

Availability

Reviews

This is why web servers are particularly important for web applications.

🏪 Real-World Example

Think about a restaurant.

You are the customer.

You ask:



"I'd like a pizza."



The restaurant receives your request, prepares the pizza, and gives it to you.

Similarly:

You / Browser

↓

Request

↓

Server

↓

Processes request

↓

Response

↓

Browser

The analogy isn't exact, but it helps understand the basic idea.

🖥️ Web Server Software

A physical or virtual computer can act as a server, but web server software is what handles HTTP requests and serves web content.

Common examples include:

Nginx

Apache HTTP Server

Microsoft IIS

Later, when we learn backend development, you'll also encounter application servers and runtimes such as Node.js.

For now, remember that "server" can refer to the machine/system, while "web server" can also refer to the software responsible for serving web content.

🌐 Server vs Website

These are not the same thing.

A website is the web content and application users interact with.

A server is the system that can store, process, and deliver that content.

For example:

Website

↓

HTML

CSS

JavaScript

Images

Data

Server

↓

Stores/serves resources

Processes requests

Communicates with databases

🧠 Important Concept: Server Doesn't Always Mean One Physical Computer

Modern websites can run on:

Virtual machines

Cloud infrastructure

Containers

Distributed systems

Multiple servers

A large application might have many servers working together.

We don't need to dive into that yet.

We'll understand it later when we study deployment, cloud, scalability, and DevOps.

🔄 Quick Revision

Remember:

Browser = Client

Server = Receives requests and provides resources/services

Request = What the client asks for

Response = What the server sends back

The basic cycle:

Client

↓

Request

↓

Server

↓

Processing

↓

Response

↓

Client

This simple concept will appear repeatedly throughout the course.

📝 Double Tap ❤️ For Part-6
❤19
🌐 Web Development Roadmap — Part 6

🔗 HTTP and HTTPS

We already learned that a browser sends a request to a server, and the server sends a response back.

But how do they communicate?

One of the most important answers is HTTP.

1️⃣ What Is HTTP?

HTTP stands for:

HyperText Transfer Protocol

It is a set of rules that allows clients and servers to communicate over the web.

In simple words:



HTTP defines how a browser and server exchange information.



The basic flow is:

Browser

↓

HTTP Request

↓

Server

↓

HTTP Response

↓

Browser

2️⃣ What Is an HTTP Request?

When your browser wants something from a server, it sends an HTTP request.

For example, you enter:

example.com

Your browser may send a request asking for the webpage.

A request contains information that helps the server understand what the browser wants.

3️⃣ What Is an HTTP Response?

After receiving the request, the server sends an HTTP response.

The response can contain:

HTML

CSS

JavaScript

JSON

Images

Other information

So:

Request = "I want this resource."

Response = "Here is the resource/result."

4️⃣ HTTP Methods

HTTP provides different methods for different types of actions.

The most common ones are:

GET

Used to retrieve data.

Example:

GET /products

Meaning:



Give me the products.



POST

Used to send/create data.

For example, creating a new account:

POST /users

PUT

Usually used to replace/update existing data.

PATCH

Used to partially update data.

DELETE

Used to delete data.

For example:

DELETE /users/25

Meaning:



Delete user 25.



You'll use these extensively when we learn REST APIs and backend development.

🛒 Real-World Example

Imagine an online shopping application.

View products

GET /products

The server returns product information.

Create an order

POST /orders

The browser sends order information to the server.

Update an order

PATCH /orders/100

The browser asks the server to update part of the order.

Delete something

DELETE /cart/items/5

The browser asks the server to remove an item.

So HTTP methods help communicate the intended action.

5️⃣ HTTP Status Codes

The server also sends a status code with its response.

You've probably encountered some of these.

200 — OK

The request was successful.

201 — Created

Something was successfully created.

400 — Bad Request

The request contains something invalid or cannot be processed as sent.

401 — Unauthorized

Authentication is required or the provided authentication is not valid.

403 — Forbidden

The server understood the request but refuses to allow it.

404 — Not Found

The requested resource couldn't be found.

500 — Internal Server Error

Something went wrong on the server.

🧠 Easy Way to Remember Status Codes

2xx → Success

3xx → Redirection

4xx → Client/request-related error

5xx → Server error

You don't need to memorize every status code right now.

These are enough to start:

200, 201, 400, 401, 403, 404, 500

6️⃣ What Is HTTPS?

HTTPS stands for:

HyperText Transfer Protocol Secure

HTTPS is HTTP with an encrypted connection using TLS (Transport Layer Security).

This helps protect data while it travels between your browser and the server.
❤2
For example, imagine you're logging into a website.

Without appropriate encryption, sensitive information could be exposed while being transmitted.

With HTTPS:

Browser

↓

Encrypted communication

↓

Server

The goal is to prevent others on the network from simply reading the transmitted data.

🔐 HTTP vs HTTPS

HTTP: Not encrypted by TLS, Less suitable for sensitive communication, Uses http://

HTTPS: Encrypted using TLS, Protects data in transit, Uses https://

Modern websites should generally use HTTPS.

You'll learn more about certificates, TLS, and web security later.

🔒 What Does HTTPS Protect?

HTTPS helps protect data in transit.

For example:

Login information

Payment information

Personal information

API communication

It doesn't mean the entire application is automatically secure.

A website can still have vulnerabilities even when it uses HTTPS.

That's an important distinction.

🧩 HTTP in a Real Application

Suppose you're using a food delivery application.

You click:

"Order Now"

A simplified process could be:

Browser

↓

POST /orders

↓

Server

↓

Process order

↓

Database

↓

Server

↓

201 Created

↓

Browser

The browser and server communicate using HTTP.

Later, we'll learn how to build these requests ourselves using JavaScript.

🔄 Quick Revision

Remember these five ideas:

HTTP → Rules for communication between clients and servers.

Request → Sent by the client.

Response → Sent by the server.

HTTP methods → Describe the intended operation, such as GET, POST, PATCH, and DELETE.

HTTPS → HTTP communication protected using TLS encryption.

A simple picture:

Browser

↓

HTTPS Request

↓

Server

↓

HTTPS Response

↓

Browser

📝 Double Tap ❤️ For Part-7
❤16👏1
🌐 Web Development Roadmap — Part 7

🔗 URLs, Domains & DNS

When you open a website, you usually type something like:

https://www.example.com/products

But what does each part mean?

To understand this, we need to learn three concepts:

URL → Domain → DNS

1️⃣ What Is a URL?

URL stands for:

Uniform Resource Locator

A URL is the address used to locate a resource on the web.

For example:

https://www.example.com/products/123?color=black

A URL can contain several parts.

https://www.example.com/products/123?color=black

↓ ↓ ↓ ↓

Protocol Domain Path Query

Let's break it down.

2️⃣ Protocol

In:

https://www.example.com

https is the protocol.

It tells the browser how communication should take place.

We've already learned about HTTPS.

You may also see:

http://

but modern websites commonly use HTTPS.

3️⃣ Domain Name

In:

https://www.example.com

the domain is:

example.com

A domain name is a human-readable name used to identify a website or Internet service.

It's much easier to remember:

example.com

than an IP address such as:

93.184.216.34

We'll discuss IP addresses shortly.

4️⃣ Subdomain

In:

https://www.example.com

www is a subdomain.

Other examples could be:

blog.example.com

shop.example.com

api.example.com

A company might use different subdomains for different services.

For example:

www.example.com

↓

Main website

blog.example.com

↓

Blog

api.example.com

↓

API

5️⃣ Path

Consider:

https://example.com/products/123

The part:

/products/123

is the path.

It identifies the particular resource or route being requested.

For example:

/products

could represent a product listing.

And:

/products/123

could represent product number 123.

6️⃣ Query Parameters

Consider:

https://example.com/products?category=shoes&sort=price

Everything after ? represents query parameters.

Here:

category=shoes

sort=price

The website can use these values to determine what information to return or how to display it.

For example:

/products?category=shoes

could mean:



Show products in the shoes category.



7️⃣ Fragment

You may also see a URL such as:

https://example.com/about#contact

The part:

contact

is called a fragment.

It can identify a particular section within a page.

For example:

<h2 id="contact">Contact Us</h2>
❤4
Opening:

contact

can take you directly to that section.

🧩 Complete URL Example

Let's analyze:

https://shop.example.com/products/123?color=black#reviews

Part Meaning

https Protocol

shop Subdomain

example.com Domain

/products/123 Path

?color=black Query parameter

reviews Fragment

You don't need to memorize every part immediately. The important thing is to understand what each component does.

🌍 What Is an IP Address?

Computers communicate using IP addresses.

An IP address identifies a device or network interface on a network.

For example:

192.168.1.10

is an example of an IPv4 address used within a private network.

A public server can also have a public IP address.

The problem is that remembering IP addresses for websites would be inconvenient.

Imagine having to remember:

142.250.x.x

instead of:

google.com

That's where DNS comes in.

📖 What Is DNS?

DNS stands for:

Domain Name System

DNS translates human-readable domain names into IP addresses that computers can use to locate services on the network.

Think of DNS like the Internet's phone book.

You know the person's name.

The phone system needs their phone number.

Similarly:

Domain name

↓

DNS

↓

IP address

For example:

example.com

↓

DNS lookup

↓

IP address

↓

Server

🔄 What Happens When You Enter a Domain?

Suppose you type:

example.com

into your browser.

A simplified version is:

1. You enter example.com

↓

1.

Browser needs the server's IP address

↓

2.

DNS lookup

↓

3.

DNS returns an IP address

↓

4.

Browser connects to the server

↓

5.

Browser sends an HTTP/HTTPS request

↓

6.

Server sends a response

↓

7.

Browser displays the website

This connects several concepts we've already learned.

🧠 Putting Everything Together

Let's combine Parts 1–7.

You type:

https://shop.example.com/products/123

Step 1

The browser receives the URL.

Step 2

The browser uses DNS to find the IP address associated with the domain.

Step 3

The browser connects to the appropriate server.

Step 4

The browser sends an HTTPS request.

Step 5

The server processes the request.

Step 6

The server sends an HTTPS response.

Step 7

The browser processes the returned resources and displays the webpage.

So:

URL

↓

DNS

↓

IP Address

↓

Server

↓

HTTPS Request

↓

HTTPS Response

↓

Browser

↓

Webpage

🎯 This is the foundation of how the web works.

📝 Double Tap ❤️ For Part-8
❤8
💻 Programming Languages A–Z 🌐

🔹 A — Assembly ➜ Low-level language used for hardware-level programming

🔹 B — Bash ➜ Scripting language commonly used for Linux and automation

🔹 C — C ➜ General-purpose language widely used for systems and embedded programming

🔹 D — Dart ➜ Language used primarily for building applications with Flutter

🔹 E — Elixir ➜ Functional language designed for scalable and fault-tolerant systems

🔹 F — Fortran ➜ Language widely used in scientific and numerical computing

🔹 G — Go ➜ Language designed for efficient, concurrent, and scalable software

🔹 H — Haskell ➜ Purely functional programming language

🔹 I — Inform 7 ➜ Language designed for creating interactive fiction

🔹 J — Java ➜ Popular language used for enterprise, backend, and Android development

🔹 K — Kotlin ➜ Modern language widely used for Android and JVM development

🔹 L — Lua ➜ Lightweight scripting language often embedded in applications and games

🔹 M — MATLAB ➜ Language and environment for numerical computing and engineering

🔹 N — Nim ➜ Compiled language focused on performance and expressive syntax

🔹 O — Objective-C ➜ Language historically used for Apple software development

🔹 P — Python ➜ Popular language for AI, data science, automation, web development, and scripting

🔹 Q — Q# ➜ Language designed for quantum programming

🔹 R — R ➜ Language focused on statistics, data analysis, and visualization

🔹 S — Swift ➜ Modern language for Apple platform development

🔹 T — TypeScript ➜ JavaScript with static typing and additional language features

🔹 U — Unicon ➜ General-purpose language derived from Icon

🔹 V — Visual Basic ➜ Language used for Windows applications and automation

🔹 W — Wolfram Language ➜ Language for computation, mathematics, and symbolic programming

🔹 X — X++ ➜ Language used primarily with Microsoft Dynamics 365 Finance and Operations

🔹 Y — Yorick ➜ Programming language designed for scientific computing

🔹 Z — Zig ➜ Systems programming language focused on performance and low-level control 

💡 Double Tap ❤️ For More
❤17👏1
🚀 Build Real Projects 🏗️🔥

Companies don't hire developers just because they know programming languages. 

They hire people who can solve real-world problems and showcase working projects.

🧠 Why Are Projects Important? 
Projects help you: 
• ✔ Apply theoretical knowledge in real scenarios
• ✔ Improve problem-solving skills
• ✔ Build a professional portfolio
• ✔ Gain confidence in coding
• ✔ Prepare for technical interviews
• ✔ Stand out from other candidates

A strong portfolio often speaks louder than a list of certifications.

🚀 How to Build a Project 
Follow this simple process: 
• Choose an Idea
• Plan Features
• Design the UI
• Write Code
• Test the Application
• Deploy Online
• Add to GitHub Portfolio

Don't aim for perfection in your first project. Focus on learning.

🌱 Beginner Projects 
If you're just starting, build simple projects first. 
Examples: 
• ✔ Calculator
• ✔ To-Do List App
• ✔ Digital Clock
• ✔ Number Guessing Game
• ✔ Quiz Application
• ✔ Weather App using an API

These projects strengthen your programming fundamentals.

💻 Intermediate Projects 
Once you're comfortable, build projects that involve databases and APIs. 
Examples: 
• ✔ Expense Tracker
• ✔ Student Management System
• ✔ Library Management System
• ✔ Blog Website
• ✔ Notes Application
• ✔ Movie Search App

These projects teach CRUD operations, authentication, and data handling.

🌟 Advanced Projects 
Now challenge yourself with real-world applications. 
Examples: 
• ✔ E-commerce Website
• ✔ Chat Application
• ✔ Video Streaming Platform
• ✔ Food Delivery App
• ✔ Social Media Platform
• ✔ Learning Management System LMS

These projects demonstrate advanced development skills.

🤖 AI & Data Science Projects 
If you've chosen the AI or Data Science path, try building: 
• ✔ AI Chatbot
• ✔ Resume Screening System
• ✔ Fake News Detector
• ✔ Image Classification Model
• ✔ Recommendation System
• ✔ Sales Forecasting Dashboard

These projects showcase practical AI and machine learning skills.

📱 Mobile App Projects 
For App Development learners: 
• ✔ Expense Tracker App
• ✔ Habit Tracker
• ✔ Fitness App
• ✔ Food Ordering App
• ✔ Notes App
• ✔ Chat App

Publish them and share them in your portfolio.

🌐 Full Stack Projects 
To demonstrate end-to-end development skills, build: 
• ✔ Authentication System Login & Signup
• ✔ Task Management System
• ✔ Online Shopping Website
• ✔ Job Portal
• ✔ Hotel Booking System
• ✔ Event Management Platform

These projects combine frontend, backend, databases, and deployment.

📂 Create a Portfolio Website 
Every developer should have a portfolio website. 
Include: 
• ✔ About Me
• ✔ Skills
• ✔ Projects
• ✔ Resume
• ✔ Contact Information
• ✔ GitHub Profile

This becomes your digital resume.

📤 Upload Projects to GitHub 
For every project: 
• ✔ Write clean code
• ✔ Add a detailed README file
• ✔ Include screenshots or GIFs
• ✔ Explain installation steps
• ✔ Mention technologies used

A well-documented repository leaves a strong impression.

🌍 Deploy Your Projects 
Don't keep projects only on your computer. 

Deploy them using platforms like: 
• ✔ Vercel for Frontend
• ✔ Render for Backend
• ✔ Netlify for Static Sites

Share live links in your resume and LinkedIn profile.

🛠 Technologies You'll Use 
Depending on your path, your projects may include:

Web Development 
• ✔ HTML
• ✔ CSS
• ✔ JavaScript
• ✔ React
• ✔ Node.js
• ✔ MySQL / MongoDB

Data Science & AI 
• ✔ Python
• ✔ Pandas
• ✔ NumPy
• ✔ Scikit-learn
• ✔ TensorFlow

Mobile Development 
• ✔ Flutter
• ✔ React Native
• ✔ Kotlin

💼 Build Projects That Solve Real Problems 

The best projects solve actual problems. 

Examples: 
• ✔ Attendance Management System
• ✔ Hospital Management System
• ✔ Inventory Tracker
• ✔ Invoice Generator
• ✔ Online Voting System
• ✔ Employee Management System

Problem-solving projects stand out during interviews.

Double Tap ❤️ For More
❤28👍1🔥1
Which technology is primarily used to structure a webpage?
Anonymous Quiz
8%
A. CSS
8%
B. JavaScript
82%
C. HTML
3%
D. Node.js
❤2
Which of the following is primarily a backend technology?
Anonymous Quiz
7%
A. HTML
3%
B. CSS
81%
C. Node.js
9%
D. React
❤1
🌐 Web Development Roadmap — Part 9

🖥️ Static Websites vs Dynamic Websites

We already learned about:

• Frontend

• Backend

• Servers

• Databases

• How browsers communicate with servers

Now let's understand an important difference:

Static website vs Dynamic website

1️⃣ What Is a Static Website?

A static website delivers webpages whose content is generally fixed unless someone changes the underlying files.

For example:

index.html

about.html

contact.html

style.css

script.js

When a user requests a page, the server can simply provide the relevant files.

Browser

↓

Request

↓

Server

↓

HTML/CSS/JS files

↓

Browser

Examples

• Personal portfolio

• Company information page

• Documentation site

• Landing page

• Basic blog

can be built as a static website.

2️⃣ What Is a Dynamic Website?

A dynamic website can generate or retrieve content based on the user, request, stored data, or application logic.

For example, consider an online shopping website.

Two users might see different information because the application retrieves data based on their accounts, preferences, cart, or orders.

A simplified flow:

Browser

↓

Request

↓

Backend

↓

Database

↓

Backend processes data

↓

Response

↓

Browser

🛒 Real-World Example

Imagine an online store.

Static approach

A product page might contain:

Phone

₹25,000

Available

The information is written directly into the webpage files.

If the price changes, someone needs to update the content.

Dynamic approach

The product information can be stored in a database:

Product ID: 101

Name: Phone

Price: ₹25,000

Stock: 18

When someone visits the product page:

Browser

↓

Request product 101

↓

Backend

↓

Database

↓

Product information

↓

Backend

↓

Browser

The webpage can then display the current information.

3️⃣ Static Doesn't Mean "No JavaScript"

This is an important point.

A static website can still use JavaScript.

For example, a static website could have:

A menu that opens when clicked

• Animations

• A calculator

• Form validation

• Interactive components

So:



Static does not mean "not interactive."



It mainly refers to how the content is delivered and generated.

4️⃣ Dynamic Doesn't Mean "Everything Changes"

A dynamic website doesn't mean that every part of the page changes constantly.

It means that some content or behaviour can be generated or retrieved dynamically.

For example, a product website may have:

• Header → Mostly the same

• Navigation → Mostly the same

• Product information → Retrieved dynamically

• User information → Retrieved dynamically

• Cart → User-specific

🧩 Static vs Dynamic

Static Website | Dynamic Website

Content generally comes from predefined files | Content can be generated or retrieved dynamically

Often simpler architecture | Usually more application logic

May not require a database | Often uses a database

Good for many informational sites | Useful for interactive data-driven applications

Easier to start with | Usually more complex

Neither approach is automatically appropriate for every website. The choice depends on the application's requirements.

5️⃣ What About a Blog?

A blog can use either approach.

Static blog

Posts can be generated into HTML pages during a build process.
❤3
Markdown/content

↓

Build process

↓

HTML pages

↓

Browser

Dynamic blog

Posts can be stored in a database.

Browser

↓

Backend

↓

Database

↓

Posts

↓

Backend

↓

Browser

Both approaches can produce a blog.

6️⃣ What About YouTube?

A platform like YouTube is highly dynamic.

When you log in, the application can retrieve information such as:

Your subscriptions

Recommended videos

Watch history

Comments

Playlists

Notifications

Much of this information depends on data and application logic.

A simplified architecture might look like:

User

↓

Frontend

↓

Backend / APIs

↓

Databases & other services

↓

Backend

↓

Frontend

↓

User

🧠 Easy Way to Remember

Think of a restaurant menu.

Static

The menu is printed on paper.

Everyone receives essentially the same predefined menu.

Dynamic

The restaurant system can generate information based on:

Current availability

Customer

Location

Time

Special offers

The information can change based on the situation.

Again, this is only an analogy, but it helps distinguish the concepts.

Static ≠ non-interactive

Dynamic ≠ every element changes

The key difference is how content and application behaviour are produced and delivered.

Double Tap ❤️ For More
❤11
🌐 Web Development Roadmap — Part 10

🛠️ Developer Tools — The Tools Every Web Developer Needs

Web development isn't only about writing code. Developers also use a set of tools to write, inspect, test, debug, manage, and deploy their applications.

Let's understand the most important ones.

1️⃣ Code Editor

A code editor is where you write your code.

A popular choice is: Visual Studio Code (VS Code)

You can use it to write:

• HTML

• CSS

• JavaScript

• TypeScript

• React

• Node.js

• Python

• And many other languages

For example, you might have a project like:

my-website/

• index.html

• style.css

• script.js

You can open the entire folder in VS Code and work on all these files.

Useful VS Code features

• Syntax highlighting

• Code completion

• Extensions

• Integrated terminal

• Debugging

•

Search

across files

•

Git integration

We'll use a code editor extensively throughout this course.

2️⃣ Web Browser

We've already learned that browsers display websites.

For a developer, the browser is also a development tool.

Common choices include:

• Chrome

• Edge

• Firefox

• Safari

You'll use a browser to:

• Run your website

• Test functionality

• Check responsive layouts

• Inspect HTML and CSS

• Debug JavaScript

• Monitor network requests

3️⃣ Browser Developer Tools

Developer Tools are built directly into modern browsers.

You can usually open them by: Right-click → Inspect or by using a keyboard shortcut.

They provide several important tools.

Elements

Allows you to inspect HTML and CSS.

For example: <button>Buy Now</button>

You can inspect the button and see which CSS rules are affecting it.

You can even temporarily modify the CSS in Developer Tools and immediately see the result.

This is extremely useful when debugging layouts.

Console

The Console is mainly used for:

• JavaScript output

• Errors

• Warnings

• Debugging

For example: console.log("Hello Web Developer");

The message appears in the browser console.

Later, you'll use the Console frequently while learning JavaScript.

Network

The Network panel shows communication between the browser and servers.

You can see:

• Request

• Response

• URL

• Status code

• Request method

• Response data

• Loading time

For example: GET /products - 200 OK

This becomes particularly useful when working with APIs.

Application

The Application panel can help inspect browser-side storage and other resources, including:

• Cookies

• Local storage

• Session storage

• Cache-related information

We'll use this later when learning authentication and browser storage.

Sources

The Sources panel helps you inspect loaded source files and debug JavaScript.

4️⃣ Terminal

The terminal allows you to interact with your computer using commands rather than a graphical interface.

For example: mkdir my-project creates a folder.

You might also run commands such as:

• npm install

• npm run dev

Later, you'll use the terminal to:

• Create projects

• Install packages

• Run development servers

• Execute scripts

• Work with Git

• Build applications

• Deploy applications

You don't need to memorize commands now. We'll learn them gradually.

5️⃣ Package Manager

Modern web applications often use external libraries and packages.
❤12
A package manager helps developers install and manage them.

For JavaScript development, one of the most common package managers is: npm

For example: npm install express

This can install Express into a project.

We'll learn npm properly when we reach Node.js.

6️⃣ Git

Git is a version control system.

It tracks changes to your code.

Imagine you modify your application today and accidentally break something tomorrow.

With Git, you can keep a history of changes and potentially return to an earlier version.

A simplified workflow:

Write code → Save changes → Git commit → Continue working → More changes → Another commit

Git becomes essential when working professionally.

7️⃣ GitHub

GitHub is a platform for hosting Git repositories and collaborating on software projects.

You can use it to:

• Store your code

• Share projects

• Collaborate with developers

• Review changes

• Create pull requests

• Track issues

• Build a public developer portfolio

A typical workflow is: Your Computer → Git → GitHub → Remote Repository

We'll learn Git and GitHub in detail later.

8️⃣ API Testing Tools

When working with backend APIs, developers often need to send requests without using a frontend.

Tools such as Postman can help with this.

For example, you might send: GET /users and inspect the server's response.

This is useful when developing and debugging APIs.

We'll introduce API testing once we reach backend development.

9️⃣ Database Tools

When we start working with databases, we'll also use database clients and tools to:

• Create databases

• Create tables

• Run SQL queries

• Inspect data

• Debug database problems

For PostgreSQL, tools such as pgAdmin can provide a graphical interface.

We'll learn database tools when we reach the database section.

🔟 How These Tools Work Together

A typical beginner web development workflow might look like:

VS Code → Write Code → Web Browser → Developer Tools → Debug & Test → Git → GitHub

Later, when we become full-stack developers:

VS Code → Frontend + Backend → Browser → Developer Tools → API Testing → Database → Git → GitHub → Deployment

🧠 The Most Important Tools to Remember

At this stage, focus on these:

• VS Code → Write code

• Browser → Run and view websites

• Developer Tools → Inspect and debug websites

• Terminal → Run commands and development tools

• Git → Track code changes

• GitHub → Store and collaborate on code

• npm → Manage JavaScript packages

Double Tap ❤️ For Part 11
❤15
Which tool can be used to test APIs without building a frontend first?
Anonymous Quiz
60%
A. Postman
4%
B. Photoshop
16%
C. Chrome Extensions
19%
D. GitHub
❤1
🌐 Web Development Roadmap — Part 11

📁 Files, Folders & Project Structure

Before we start writing HTML

, CSS, and JavaScript, you need to understand how a web development project is organized.

A website isn't usually one giant file. A real project contains multiple files and folders, each with a specific purpose.

1️⃣ What Is a File?

A file is a container that stores information.

In web development, you'll commonly work with files such as:

.html

.css

.js

.json

.ts

.jsx

.tsx

For example:

index.html

style.css

script.js

Each file can have a different responsibility.

2️⃣ What Is a Folder?

A folder is used to organize files and other folders.

For example:

my-website/
│
├── index.html
├── style.css
├── script.js
│
├── images/
│ ├── logo.png
│ └── profile.jpg
│
└── pages/
├── about.html
└── contact.html


Here:

my-website/

is the main project folder.

Inside it are files and additional folders.

3️⃣ Why Do We Need Project Structure?

Imagine putting every file for a large application into one folder without organization.

You might eventually have:

100+ files

Finding the correct file would become difficult.

A good structure makes it easier to:

Find files

Understand the project

Maintain code

Work with other developers

Scale the application

4️⃣ The Basic Website Structure

For a beginner website, you can start with:

my-website/
│
├── index.html
├── style.css
└── script.js


Each file has a different job.

index.html

Contains the webpage structure.

<h1>My Website</h1>
<p>Welcome to my website.</p>


style.css

Controls the appearance.

h1 {
color: blue;
}


script.js

Adds behaviour.

console.log("Website loaded");


The browser can connect these files together.

5️⃣ The index.html File

You'll see index.html very often.

It is commonly used as the main or default HTML page of a website.

For example:

my-website/
│
└── index.html


When someone visits the main page of a simple website, the server may serve the index.html document.

It's a convention rather than a universal rule for every web application.

6️⃣ Organizing Images

Instead of putting every image directly in the project root, we can create an images folder.

my-website/
│
├── index.html
├── style.css
├── script.js
│
└── images/
├── logo.png
├── laptop.jpg
└── phone.jpg


Then HTML can reference an image inside that folder.

<img src="images/logo.png" alt="Logo">


The path:

images/logo.png

tells the browser where the image is located relative to the HTML file.

7️⃣ Multiple Pages

A website can contain multiple HTML pages.

For example:

my-website/
│
├── index.html
├── about.html
├── contact.html
│
├── css/
│ └── style.css
│
└── images/
└── logo.png


You could have:

index.html → Home

about.html → About

contact.html → Contact

This is a simple way to understand how multi-page websites are structured.

8️⃣ Relative Paths

Understanding file paths is extremely important.

Suppose you have:

project/
│
├── index.html
│
└── images/
└── logo.png


From index.html, you can reference the image using:

<img src="images/logo.png">


Now suppose you have:

project/
│
├── pages/
│ └── about.html
│
└── images/
└── logo.png


From about.html, you need to go up one folder first:

<img src="../images/logo.png">
❤5
Here:

../

means:



Go up one directory.



This concept becomes very important as projects become larger.

9️⃣ Common Project Folders

As applications become more complex, you'll encounter folders such as:

src/

components/

pages/

assets/

images/

styles/

utils/

services/

Their exact purpose depends on the project and framework.

For example:

src/
├── components/
├── pages/
├── services/
├── assets/
└── styles/


We'll learn these structures when we start working with React and larger applications.

🔟 A Real-World Project

A simple website might look like:

portfolio/
│
├── index.html
├── about.html
├── contact.html
│
├── css/
│ └── style.css
│
├── js/
│ └── script.js
│
└── images/
├── profile.jpg
└── project1.png


A larger modern application might eventually look more like:

my-app/
│
├── src/
│ ├── components/
│ ├── pages/
│ ├── services/
│ ├── assets/
│ └── styles/
│
├── public/
├── package.json
├── README.md
└── .gitignore


Don't worry about understanding all of these folders yet.

We'll introduce them when we actually need them.

🧠 Key Things to Remember

File → Stores information or code.

Folder → Organizes files.

index.html → Common default/main HTML document.

images/ → Can organize image files.

css/ → Can organize CSS files.

js/ → Can organize JavaScript files.

../ → Moves up one directory in a relative path.



A good project structure keeps code organized and makes applications easier to understand and maintain.



Double Tap ❤️ For Part 12
❤9