What is Laravel?

Laravel is a modern, open-source PHP framework designed for building robust, maintainable, and scalable web applications. Created by Taylor Otwell and released in 2011, Laravel has quickly become one of the most popular PHP frameworks worldwide, renowned for its elegant syntax, developer-friendly tools, and rich ecosystem.

Laravel is built on the Model-View-Controller (MVC) architectural pattern, which separates application logic (Model), user interface (View), and request handling (Controller). This separation of concerns improves code organization and facilitates collaboration.

Laravel abstracts many common web development tasks — routing, authentication, sessions, caching, database interactions, and more — providing an expressive and powerful syntax that allows developers to focus on application-specific logic rather than boilerplate code.

Additionally, Laravel integrates seamlessly with modern frontend tools, REST APIs, queues, task scheduling, real-time event broadcasting, and testing frameworks, making it ideal for both simple websites and complex enterprise applications.

What are the Major Use Cases of Laravel?

Laravel’s versatility and comprehensive feature set make it suitable for a wide variety of application types and industries:

1. Content Management Systems (CMS) and Blogs

Laravel’s modular structure, routing flexibility, and templating engine (Blade) make it an excellent choice for building content-heavy platforms, blogs, and CMS solutions where dynamic content management and user roles are essential.

2. E-commerce Applications

Robust e-commerce platforms demand complex features like product catalogs, shopping carts, payment gateways, order management, and customer accounts. Laravel offers built-in tools for handling authentication, validation, queues, and notifications, streamlining the development of e-commerce websites.

3. Enterprise-Level Applications

Enterprises often require complex applications involving workflow automation, reporting, multi-user role management, and integration with legacy systems. Laravel’s architecture supports building scalable and maintainable business applications with features like service containers and event-driven design.

4. RESTful API Development

Laravel makes building RESTful APIs straightforward through resource controllers, API authentication (via Laravel Sanctum or Passport), and rate limiting middleware. It supports JSON responses natively and integrates easily with frontend frameworks like React, Vue.js, and Angular.

5. Social Networks and Real-Time Apps

Features such as real-time event broadcasting (Laravel Echo), notifications, and task queues make Laravel suitable for building social platforms and interactive applications requiring real-time communication.

6. Microservices and Modular Systems

Laravel’s service container and package system facilitate modular development, making it possible to build microservices architectures or component-based applications.

7. Task Automation and Background Jobs

Laravel includes a native scheduler and robust queue system, allowing background processing of tasks like emails, report generation, and API calls asynchronously to improve performance.

How Laravel Works Along with Architecture?

Laravel’s architecture is a well-designed blend of established software design principles and modern PHP features, structured around several key components:

1. Model-View-Controller (MVC) Pattern

• Model: Represents the data layer, typically using Laravel’s Eloquent ORM to interact with databases via expressive ActiveRecord syntax. Models define database tables, relationships, and business logic related to data.
• View: Uses Laravel’s Blade templating engine to render HTML dynamically. Blade supports template inheritance, components, and simple PHP embedding, enabling clean and maintainable frontend code.
• Controller: Handles user input and requests, coordinates with models to retrieve or store data, and returns responses by rendering views or JSON for APIs.

2. Routing Layer

Laravel’s routing system maps HTTP requests to controllers or closure functions. It supports RESTful routing, route groups, middleware, named routes, and route model binding, offering flexible URL handling.

3. Service Container and Dependency Injection

The service container is Laravel’s powerful tool for managing class dependencies and performing dependency injection. It promotes loose coupling and testability by automatically injecting required services into controllers or other classes.

4. Middleware

Middleware layers act as filters for HTTP requests, enabling features like authentication, CSRF protection, logging, and CORS headers by processing requests before they reach routes or controllers.

5. Database and Eloquent ORM

Laravel supports multiple database systems and provides:

• Migrations: Version-controlled schema changes.
• Query Builder: Fluent interface for database queries.
• Eloquent ORM: ActiveRecord implementation that maps models to tables and supports complex relationships (one-to-many, many-to-many, polymorphic).

6. Queues and Task Scheduling

Queues enable deferring time-consuming tasks (emails, notifications) using various backends like Redis or database queues. The scheduler allows cron-like task automation within Laravel’s ecosystem.

7. Event System

Laravel’s event broadcasting supports decoupled event-driven programming, enabling real-time notifications and asynchronous processing.

8. Security

Laravel includes built-in mechanisms for password hashing, input validation, SQL injection prevention, cross-site scripting (XSS) protection, and CSRF tokens.

9. Testing

Laravel integrates PHPUnit and provides helpers for HTTP testing, database transactions, and mocking services, facilitating robust automated testing.

What are the Basic Workflow of Laravel?

The typical Laravel development workflow follows these stages:

1. Project Setup

Initialize a new Laravel project using Composer and configure environment variables.

2. Routing and Controllers

Define routes in routes/web.php or routes/api.php and link them to controller methods that handle requests.

3. Database Schema Design

Define migrations to create and modify database tables and run migrations to update the database schema.

4. Model Creation

Create Eloquent models corresponding to database tables, defining relationships and business logic.

5. View Development

Design Blade templates to render data dynamically and create reusable components.

6. Implement Business Logic

Handle data manipulation in controllers and models, applying validation and authorization rules.

7. Background Processing

Configure queues and schedule tasks for asynchronous processing.

8. Testing

Write and execute unit and feature tests to verify application correctness.

9. Deployment

Prepare the application for production with caching, optimization, and environment configuration.

Step-by-Step Getting Started Guide for Laravel

Step 1: Install Composer

Ensure Composer is installed for PHP dependency management.

curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer

Step 2: Create a New Laravel Project

Create a fresh Laravel project via Composer:

composer create-project --prefer-dist laravel/laravel myproject
cd myproject

Step 3: Configure Environment Variables

Copy .env.example to .env and update database credentials and other settings.

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel_db
DB_USERNAME=root
DB_PASSWORD=secret

Step 4: Generate Application Key

Run the key generator to set the application encryption key:

php artisan key:generate

Step 5: Run Database Migrations

Create the initial database schema:

php artisan migrate

Step 6: Serve the Application

Start the built-in development server:

php artisan serve

Visit http://127.0.0.1:8000 in your browser.

Step 7: Create a Model and Controller

Generate a model and corresponding controller:

php artisan make:model Post -m
php artisan make:controller PostController --resource

The -m flag creates a migration file.

Step 8: Define Database Schema

Edit the migration file in database/migrations to define columns:

Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('content');
    $table->timestamps();
});

Run migrations:

php artisan migrate

Step 9: Define Routes

In routes/web.php:

Route::resource('posts', PostController::class);

Step 10: Implement Controller Logic

Populate controller methods (index, show, store, etc.) to interact with the Post model.

Step 11: Create Blade Views

In resources/views/posts/, create Blade templates (index.blade.php, show.blade.php, create.blade.php).

What is Laravel?

Laravel is an open-source PHP web framework designed for building robust, scalable, and modern web applications. It was created by Taylor Otwell and released in 2011 to provide an alternative to other PHP frameworks like CodeIgniter and Yii. Laravel is based on the Model-View-Controller (MVC) architectural pattern, which helps in organizing the application logic by separating concerns such as data management, user interface, and user interaction. This separation allows for easier development, maintenance, and scaling of applications.

Laravel is known for its elegant syntax, developer-friendly tools, and extensive documentation, which makes it a popular choice among web developers. Laravel provides a wide range of features out-of-the-box, including routing, database migrations, authentication, authorization, and more. Its emphasis on clean, readable code, along with built-in support for modern web technologies, makes it suitable for projects ranging from small-scale websites to large enterprise applications.

Laravel has gained widespread popularity due to its rich ecosystem of tools and services, including Laravel Forge for deployment, Laravel Vapor for serverless applications, and Laravel Echo for real-time event broadcasting. Laravel also has an integrated Eloquent ORM (Object-Relational Mapping) for database management, making it easy to interact with databases and perform CRUD operations.

What are the Major Use Cases of Laravel?

1. Building Web Applications:
   Laravel’s primary use case is building modern web applications. It offers a structured and flexible approach for handling common web development tasks such as routing, authentication, database management, and form handling. Laravel’s simplicity and clean syntax make it a great choice for both small-scale projects and enterprise-level applications.
2. Content Management Systems (CMS):
   Laravel is frequently used for developing content management systems (CMS) where flexibility and scalability are essential. Laravel’s ability to manage dynamic content and provide an administrative interface through easy-to-use backend tools makes it ideal for creating custom CMS platforms. Popular examples include OctoberCMS and Jigsaw.
3. E-commerce Platforms:
   Laravel is also well-suited for developing e-commerce websites. With built-in support for managing databases, user authentication, and payment gateways, developers can create fully functional e-commerce solutions. Laravel provides robust tools for building product catalogs, shopping carts, and order management systems. Frameworks like Bagisto and Aimeos are based on Laravel and provide pre-built e-commerce solutions.
4. API Development:
   Laravel excels at developing RESTful APIs, making it a preferred framework for building APIs for web or mobile applications. Laravel’s routing system and support for authentication (including OAuth2 and JWT) make it easy to build secure and scalable APIs. Laravel’s lightweight nature allows for fast and efficient API development.
5. Real-Time Applications:
   Laravel is also useful for building real-time applications such as chat applications, collaborative platforms, and live notifications. The Laravel Echo package allows for event broadcasting, enabling developers to easily implement real-time features in their web applications using WebSockets.
6. Task Scheduling and Automation:
   Laravel includes a built-in task scheduler that allows developers to automate repetitive tasks, such as sending out emails or running background jobs. The Laravel Scheduler provides an easy-to-use API for scheduling recurring tasks, which is useful in scenarios where tasks need to run at specific intervals.
7. Enterprise Applications:
   Laravel’s architecture and features make it suitable for large-scale enterprise applications that require complex business logic, large databases, and integration with third-party services. The scalability and flexibility of Laravel make it a popular choice for organizations that require custom-built solutions to meet specific business needs.

How Laravel Works Along with Architecture?

Laravel follows the Model-View-Controller (MVC) architecture, which separates the application logic into three primary components:

1. Model:
   The Model is responsible for interacting with the database and handling data-related logic. It represents the business logic and data structure of the application. In Laravel, models are typically associated with a specific database table and allow developers to perform CRUD (Create, Read, Update, Delete) operations using Eloquent ORM. Eloquent provides an active record implementation for database interaction, making it easy to retrieve and manipulate data in a database. Example of a Laravel model for the User table: namespace App\Models; use Illuminate\Database\Eloquent\Model; class User extends Model { protected $table = 'users'; }
2. View:
   The View is responsible for displaying the user interface of the application. In Laravel, views are typically created using Blade, Laravel’s templating engine. Blade allows developers to easily combine PHP with HTML to generate dynamic content. Views can be used to display data retrieved by the controller, such as lists of users or posts. Example of a simple Blade view: <h1>Welcome, {{ $user->name }}</h1> <p>Your email: {{ $user->email }}</p>
3. Controller:
   The Controller serves as the intermediary between the Model and the View. It receives user input (usually via HTTP requests), interacts with the Model to retrieve or modify data, and then passes the data to the View for rendering. Controllers define the application’s business logic and manage the flow of data. Example of a simple Laravel controller: namespace App\Http\Controllers; use App\Models\User; use Illuminate\Http\Request; class UserController extends Controller { public function index() { $users = User::all(); return view('users.index', compact('users')); } }

In addition to MVC, Laravel also includes several other architectural components and design patterns:

• Routing: Laravel provides a powerful routing system to map HTTP requests to specific controller actions or routes.
• Middleware: Middleware acts as a filtering mechanism to inspect incoming requests before they reach the controller or the application’s response.
• Service Providers: Service providers are used to bootstrap and configure services and bindings into Laravel’s service container.
• Artisan CLI: Laravel includes a command-line interface, Artisan, which provides a set of helpful commands for tasks like database migrations, routing, and generating boilerplate code.

What are the Basic Workflow of Laravel?

Laravel’s workflow involves several key steps, each designed to make development as efficient as possible. Here is an overview of the basic workflow:

1. Routing:
   When a user sends an HTTP request to a Laravel application, the request is first directed through the application’s routing system. Laravel’s routes/web.php file defines routes that map to specific controller actions or closure functions. Example of a route in Laravel: Route::get('/users', [UserController::class, 'index']);
2. Request Handling:
   After routing the request, Laravel processes the request through a series of middleware layers. Middleware functions as filters that can modify the request or perform checks before the request reaches the controller.
3. Controller Logic:
   The request is then passed to the appropriate controller, where the application’s business logic resides. The controller may interact with models to retrieve or modify data and will then pass this data to the view for rendering.
4. View Rendering:
   The controller returns a view (often using Laravel’s Blade templating engine) that contains HTML mixed with data. The view is responsible for presenting the data to the user in a structured format.
5. Response:
   After the view is rendered, Laravel sends the response back to the user’s browser, completing the request-response cycle. The response may include HTML content, JSON data (for APIs), or other types of data.

Step-by-Step Getting Started Guide for Laravel

1. Install Laravel:
   The first step in using Laravel is to install it. You can install Laravel using Composer, which is a dependency management tool for PHP. To install a new Laravel project, run the following command in your terminal: composer create-project --prefer-dist laravel/laravel your-project-name
2. Set Up Environment:
   After installation, navigate to the project folder and configure your environment. The .env file in the Laravel project holds environment-specific configurations such as database connections, app URL, and API keys. Example of .env file configuration: APP_NAME=Laravel APP_ENV=local APP_KEY=base64:your-app-key DB_CONNECTION=mysql DB_HOST=127.0.0.1 DB_PORT=3306 DB_DATABASE=your_database DB_USERNAME=root DB_PASSWORD=
3. Configure Database:
   Set up your database by updating the .env file with your database connection details. Laravel supports various databases such as MySQL, PostgreSQL, SQLite, and SQL Server.
4. Create a Model:
   To interact with the database, create a model using Artisan. For example, to create a User model, run: php artisan make:model User
5. Define Routes:
   Define the routes for your application in the routes/web.php file. Routes handle incoming requests and map them to specific controller actions.
6. Create Controllers:
   Controllers contain the logic for handling requests. You can create a controller using the Artisan command: php artisan make:controller UserController
7. Create Views:
   Views are stored in the resources/views directory and can be created using Blade templates. Laravel uses Blade to render views dynamically with data passed from controllers.
8. Run the Application:
   You can start the Laravel development server by running: php artisan serve Once the server is running, you can visit http://localhost:8000 to view your application.

Laravel is a free and open-source PHP web framework, created by Taylor Otwell and intended for the development of web applications following the model–view–controller (MVC) architectural pattern and based on Symfony.

Some of the features of Laravel are:

• A modular packaging system with a dedicated dependency manager, different ways for accessing relational databases, utilities that aid in application deployment and maintenance, and its orientation toward syntactic sugar.
• A powerful command-line interface (CLI) called Artisan, which can be used to generate new code, migrate databases, and perform other tasks.
• A well-documented API that makes it easy to learn and use.
• A large and active community of developers who can provide support and help with problems.

What is top use cases of Laravel?

Laravel is a popular PHP framework that can be used to develop a wide variety of web applications. Here are some of the top use cases of Laravel:

• E-commerce websites: Laravel is a great choice for developing e-commerce websites because it is scalable and secure. Laravel also provides a number of features that are specifically designed for e-commerce websites, such as the ability to create product catalogs, manage orders, and process payments.
• Content management systems (CMS): Laravel can be used to develop custom CMSs or to extend existing CMSs. Laravel’s MVC architecture makes it easy to create a modular and extensible CMS.
• Social media applications: Laravel is a good choice for developing social media applications because it is scalable and efficient. Laravel also provides a number of features that are specifically designed for social media applications, such as the ability to handle large amounts of data and to scale to meet demand.
• APIs: Laravel can be used to develop APIs for a variety of purposes, such as connecting different systems, providing data to third-party applications, or creating a public-facing API for your application. Laravel’s API features make it easy to create secure and scalable APIs.
• Enterprise applications: Laravel is a good choice for developing enterprise applications because it is scalable, secure, and well-documented. Laravel’s features make it easy to create complex applications that meet the needs of large organizations.

What are the features of Laravel?

Laravel is a popular PHP framework that offers a wide range of features that make it a great choice for developing web applications.

Here are some of the most important features of Laravel:

• MVC architecture: Laravel follows the Model-View-Controller (MVC) architectural pattern, which separates the application into three layers: the model, the view, and the controller. This makes the application code more organized and easier to maintain.
• Routing: Laravel provides a powerful routing system that makes it easy to define and map URLs to controller actions. This makes it easy to create complex applications with a large number of URLs.
• Eloquent ORM: Laravel includes an Eloquent ORM that makes it easy to interact with databases. The Eloquent ORM provides a fluent interface that makes it easy to create, read, update, and delete data from databases.
• Artisan CLI: Laravel includes a powerful command-line interface (CLI) called Artisan that can be used to generate new code, migrate databases, and perform other tasks. The Artisan CLI makes it easy to automate tasks and speed up development.
• Security: Laravel includes a number of features that make it a secure framework, such as input validation, password hashing, and CSRF protection. These features help to protect your application from common security vulnerabilities.
• Testing: Laravel includes a built-in testing framework that makes it easy to test your application. The testing framework provides a number of tools and features that help you to write and run tests quickly and easily.
• Documentation: Laravel has excellent documentation that makes it easy to learn and use the framework. The documentation is well-written and comprehensive, and it includes examples and tutorials that can help you get started.
• Community: Laravel has a large and active community of developers who are always willing to help with problems and answer questions. This community is a great resource for learning Laravel and getting help when you need it.

What is the workflow of Laravel?

The workflow of Laravel is a process that is used to develop web applications using the Laravel framework. The workflow is divided into the following steps:

• Routing: The first step is to define the routes for your application. Routes are used to map URLs to controller actions. This is done using the Laravel routing system.
• Controllers: Controllers are responsible for handling requests from the user. They are responsible for calling the appropriate model methods and rendering the appropriate view.
• Models: Models are responsible for interacting with the database. They provide a layer of abstraction between the application and the database.
• Views: Views are responsible for displaying the data to the user. They are typically rendered by the controller.
• Testing: Testing is an essential part of the Laravel workflow. Laravel includes a built-in testing framework that makes it easy to write and run tests.

How Laravel Works & Architecture?

Laravel is a popular PHP framework that follows the Model-View-Controller (MVC) architectural pattern. The MVC pattern divides the application into three layers:

• The Model layer: The model layer is responsible for interacting with the database. It provides a layer of abstraction between the application and the database.
• The View layer: The view layer is responsible for displaying the data to the user. It is typically written in Blade, which is a templating language that is designed for Laravel.
• The Controller layer: The controller layer is responsible for handling requests from the user. It is responsible for calling the appropriate model methods and rendering the appropriate view.

How to Install and Configure Laravel?

Here are the steps on how to install and configure Laravel:

1. Install Composer. Composer is a dependency manager for PHP. You can download Composer from the Composer website.

2. Install Laravel. You can install Laravel using Composer. To do this, run the following command in your terminal:

composer create-project --prefer-dist laravel/laravel my-app

This will create a new Laravel application called my app.

3. Configure the application. You need to configure the application before you can start using it. The configuration file is located at config/app.php. In this file, you can set the application name, the database connection details, and other settings.

4. Generate a key. Laravel uses a key to encrypt sensitive data. You can generate a key using the following command:

php artisan key:generate

5. Start the development server. Laravel includes a built-in development server that you can use to test your application. To start the development server, run the following command:
php artisan serve

This usually occurs when using of Laravel Socialite for authentication

Socialite

In addition to typical, form based authentication, Laravel also provides a simple, convenient way to authenticate with OAuth providers using Laravel Socialite. Socialite currently supports authentication with Facebook, Twitter, LinkedIn, Google, GitHub, GitLab, and Bitbucket.

Error

Argument 1 passed to Illuminate\Auth\SessionGuard::login() must implement interface Illuminate\Contracts\Auth\Authenticatable, null given, called in C:\xampp\htdocs\WrokSpace\professional\vendor\laravel\framework\src\Illuminate\Auth\AuthManager.php on line 297

Solution

Just delete the social provider assigned to that user id from your database table and that’s it.

Thankyou

So i’m providing a complete list of each folder’s and sub-folder’s permissions.

1. storage – 755.
   
   
2. storage/app – 755.
   storage/app/public – 755.
   
   
3. storage/framework – 755.
   storage/framework/views – 777.
   storage/framework/testing – 755.
   storage/framework/sessions – 777.
   storage/framework/cache – 755.
   
4. storage/logs – 755.

That’s all. Hope this article will solved your problem.

Keep Exploring.

Thanks for reading.

Step :1 Create a folder anywhere in your local computer with any name (Mine is workspace)

Step:2 Make sure git and gitbash is installed in your local machine if not download it from here

Step:3 Login into your GitHub account and create a repository

Step 4: Clone the repository into your local machine

• get inside your repository

• Copy the URL under HTTPS area
• There are many more ways to clone a repo but for time being use this method
• Now get inside our workspace folder that we created before (local/workspace)
• right click and open git bash or command line inside the folder

• Run these git commands to get started

git init 

This is to initialize a new, empty repository 

git clone https://github.com/pradeeprjth/laravelTestingProject.git [HTTPS_URL_YOU_COPYED_FROM_GITHUB] 

This will clone everything stored in your remote repository into your local folder/repository
You will find a folder with the same name you created your repository 

Step :5 paste your project/code inside the folder you just clone from the repository

• Again run the below commands to push all the changes and codes back to the repository
• Right click and open your git bash or cmd inside the folder

git add .

The git add command adds a file to the Git staging area. This area contains a list of all the files you have recently changed.

git commit -m"first_commit"

git commit creates a commit, which is like a snapshot of your repository. These commits are snapshots of your entire repository at specific times. and you need to specify a commit message using -m flag including double quote

git push origin master    or    git push origin main 

git push -u origin master is used for pushing local content to GitHub

Step 6: Login to your remote machine or ubuntu machine and make sure xampp and composer is installed in that machine.

Follow this blog if xampp and composer are not installed in your remote/ubuntu machine

1. Installed Xampp

How to install and Configure XAMPP on Ubuntu?

This blog is written by Rajesh thanks to him.

2. Another thing which is required is Composer

Install composer using CLI in ubuntu (Globally)

Follow this to install composer in your machine using CLI

Stpe :7 Go to your htdocs folder or if you have lampp then www folder and run below commands

git init 

 This is to initialize a new, empty repository but this time inside your remote machine 

git clone https://github.com/pradeeprjth/laravelTestingProject.git [HTTPS_URL_YOU_COPYED_FROM_GITHUB]

Now as we already have pushed all our code into our repository so we'll get all the files folder into our htdocs folder or www folder 

Step 8: Now to run the project we need to do some configuration

• Copy the .env.example file to .env coz git ignore some files and folder including our vendor folder which contains all our Laravel project files . To do this run the below command.

cp .env.example .env

• Install composer, as git ignores our vendor folder in order to get it back we need to run

composer install

• You may get an error while composer install
• Class ‘Illuminate\Support\facades\Schema not found
• In order to solve this go to your project folder in local and inside C:\xampp\htdocs\WrokSpace\laravelTestproject\app\Providers\AppServiceProvider.php
• use this class in the top
  use Illuminate\Support\Facades\Schema;

• Next thing is to set the APP_KEY value in your .env file, run the command below

php artisan key:generate

Step 9: Now go to your browser and put your ip followed by the project name /public to visit the application

http://90.437.1965.252/laravelTestproject/public/

That’s it hope it help’s someone out there.

"^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$"

Minimum eight characters, at least one letter, one number and one special character:

"^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]{8,}$"

Minimum eight characters, at least one uppercase letter, one lowercase letter and one number:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$"

Minimum eight characters, at least one uppercase letter, one lowercase letter, one number and one special character:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$"

Minimum eight and maximum 10 characters, at least one uppercase letter, one lowercase letter, one number and one special character:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,10}$"

First permission:

As you know the first thing our browser needs to run a Laravel project is, the index file which is located in the public folder
so we need to make it read and writable so that our browser can access it and if required can modify it.

Run the below command to grant access to the public folder

cd /opt/lampp/htdocs/YOUR_PROJECT
sudo chmod -R +rw public

Second permission:

The next permission if for the storage folder, as you already know when our Laravel projects runs it create some logs files automatically if any error found in you code base,

Run the below command to grant access to the logs folder

cd /opt/lampp/htdocs/YOUR_PROJECT
sudo chmod -R +rw storage

Third permission:

At the end, the final permission we have to give to our session folder which is located inside our storage/framework folder,
and every time we hit our project URL a new random session key is generated, that get stored in our session folder
so all of them are necessary to run a Laravel project

Run the below command to grand access to the framework and session

sudo chmod -R 775 framework
sudo chmod -R 775 session

That’s it, these all works for me hope it for you too

1. Installed Xampp

2. Another thing which is required is Composer

3. Now the thing is when we try to install Laravel project inside our htdocs folder it through an error

4. To resolve this error first create a folder inside your htdocs.

mkdir Projects

5 grant read and write permissions to this folder by running this commands

sude chmod +rw Projects

6. You may get another error while installing is (“mbstring” extension is missing.)

Run the below commands to resolve these errors

sudo apt-get install php-mbstring

sudo su - root

7. That’s it now try installing your project again

composer create-project --prefer-dist laravel/laravel testProject "5.8.*"

That’s it, Hope it help someone out there.

STEP 1: Update You distribution

Enter this command to update the local repository lists.

sudo apt-get update

STEP 2: Download the Composer Installer

run the below command in your root directory (We are installing composer globally)

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"

Step 3: Verify Integrity of the Download

1. Visit the Composer Public Keys page. Copy the Installer Signature (SHA-384).
2. Set the code shell variable:

COMPOSER=48e3236262b34d30969dca3c37281b3b4bbe3221bda826ac6a9a62d6444cdb0dcd0615698a5cbe587c3f0fe57a54d8f5
3. Run the script below to compare the official hash against the one you downloaded:

php -r "if (hash_file('SHA384', 'composer-setup.php') === '$COMPOSER') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

Step 4: Install PHP Composer

1. Installing PHP Composer requires curl, unzip, and a few other utilities. Install them by entering the following:

sudo apt-get install curl php-cli php-mbstring git unzip

2. To install to /usr/local/bin. enter:

sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

The installer should output:

That’s it hope it helps someone there.