Step [1] – Installation NGINX

sudo apt install
sudo apt install nginx
sudo service nginx start

Step [2] – Create Virtual Host File magento.conf

sudo nano magento.conf && chmod 777 magento.conf

upstream fastcgi_backend {
  server  unix:/run/php/php8.2-fpm.sock;
}

server {

  listen 80;
  server_name www.magento-dev.com;
  set $MAGE_ROOT /var/www/html/magento2;
  include /var/www/html/magento2/nginx.conf.sample;
}

Step [3] – To Create nginx virtual host symbolic link

sudo ln -s /etc/nginx/sites-available/magento.conf /etc/nginx/sites-enabled/magento.conf

Step [4] – Inside /var/www/html/ below directory has been created

index.nginx-debian.html

Create magento2 folder

Step [5] – Go Windows > System 32 / Drivers / etc / host file

Set your virtual host here

Step [6]- Install PHP 8.3

sudo apt install php libapache2-mod-php php-bcmath php-curl php-fpm php-gd php-intl php-mbstring php-mysql php-soap php-xml php-xsl php-zip php-cli

Step [7] – Modify in php.ini file

To Find path of php.ini

php -ini | grep "Loaded Configuration File"

max_execution_time = 5000 

max_input_time = 5000 

memory_limit = -1

post_max_size = 900M 

upload_max_filesize = 900

Once all changes done in php.ini start php service below

sudo service php8.3-fpm start

Step [8] – Installation MYSQL

sudo apt install mysql-server

Step [9] – Start mysql Service

sudo service mysql start

Step [10] – Change Mysql Credentials

Mysql credentials as root / root123

Step [11] – Mysql Secure Installation

Step [12] – Create custom database with username / password

create database magento2461;

Create Mysql Username & Password to assign this database

create USER 'magento2461'@'localhost' IDENTIFIED  by 'TYfd1@#23asD';

Step [13] – Grant Permission assign database to user magento2461

Step [14] – Run flush privileges command

flush privileges;

Step [15] – Composer Installation

sudo curl -sS https://getcomposer.org/installer -o composer-setup.php
sudo php composer-setup.php –install-dir=/usr/local/bin –filename=composer

To Check either composer working fine

Step [16] – Remove composer-setup.php

Once installed composer, It is file composer-setup.php created, we do not need this file, need to remove

Step [17] – Elastic Search Installation

sudo wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-8.3.2-amd64.deb

sudo wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-8.3.2-amd64.deb.sha512

shasum -a 512 -c elasticsearch-8.3.2-amd64.deb.sha512

sudo dpkg -i elasticsearch-8.3.2-amd64.deb

Once Below command run & display as ok — Elastic Search packaged installed.

shasum -a 512 -c elasticsearch-8.3.2-amd64.deb.sha512

Step [18] – Elasticsearch Start command

 sudo systemctl daemon-reload
 sudo systemctl enable elasticsearch.service
 sudo systemctl start elasticsearch.service

The following below steps to install composer in Windows 10/11

Step [1] – Download Composer

Step [2] – Click on Download composer folder

Click on Install for all users(recommended)

Step [3] – Click om Developer Mode–>Next Button

Step [4] – Directory auto selected C Folder by default, if you would like to modify composer installation in other folder as per need –> Next Button

Step [5] – Here we need to set path for xampp folder as

E:\xampp\php\php.exe

Click on Next Button

Step [6] – Finally Composer has been installed.

Step [7] – Finally run below command to check either Composer working fine or not.

The following below steps to install Laravel on Windows 10/11, here we are considering XAMPP & Composer already installed in your system

Step [1] – Here we considered, Xampp & Composer has been installed in your system

Step [2] – To Check Composer working fine or not.

Step [3] – Run below Laravel Installation command

composer create-project Laravel/Laravel example-app

where example-app folder that is going to be created Once Installation Start

Step [4] – Go To inside Laravel created folder

Step [5] – Start the Laravel Server run below command inside Laravel created folder

php artisan serve

Step [6] – Finally run below command to check either Laravel Installation working fine or not.

http://127.0.0.1:8000

	BRD	FRD / FRS	SRS
Scope	Project Objective, Project Scope, Stakeholders, Success Criteria It depends on WHAT & WHY Project	All Detailed Granular Functional Requirement as form UML & Data Flow Diagram	Project’s All Functional & Non Functional Requirement Security, Performance, Reliability, Scalability Availability
Created By	Business Analyst	Functional Analyst	Business Analyst
Focus	What & Why Project is going to be created	Defines How the system will work to meet those business needs.	detailed document (functional and non-functional )requirements & providing a final or comprehensive blueprint of the system
Audience	Business Analyst, Stakeholders, Project /Product Managers	Development Team , QA Team,	Development Team , QA Team,
Prepared In	Initial Phase	Planning Phase	Planning Phase
Example	Need to improve customer experience through a new system	Users can register, search for products, and purchase online	The system must handle 1,000 users with no more than 2-second response time

The Flow of BRD (Business Requirements Document) & FRD (Functional Requirements Document) or FRS (Functional Requirements Specification) & SRS (Software Requirements Specification)

First Created- BRD (Business Requirements Document)

Second Created – FRD (Functional Requirements Document) or FRS (Functional Requirements Specification)

Third Created – SRS (Software Requirements Specification)

Step [1] – To Check Node.js Installed & Its version

The npm stands for Node Package Manager and it is the default package manager for Node.js

To check NodeJS is installed or not by running the following command

node -v

The npx stands for Node Package Execute and it comes with the npm

To check npx is installed or not by running the following command

npx -v

If NodeJS not installed,

How To Install Node.js in Windows 10 / 11

Step [2] – Run Command

npx create-react-app myapp

Here myapp project name

Step [3] – Run Below Command

npm start

Once command run successfully run, below message displaying

As we are working on Local Machine, while going deploy on Production need to be run Production Command npm run build

Note that the development build is not optimized.
To create a production build, use npm run build.

Step [4] – Run below URL in Browser

http://localhost:3000

Step [5] – ReactJs Folder Structure

Finally we have the following below set of CLI Command

node -v
npx -v
npx create-react-app myapp
npm start

http://localhost:3000

Step [6] – Install Required Contentful Packages

To interact with Contentful, we need to install the Contentful JavaScript SDK. Install it by running

npm install contentful

The following things ( Organization, Space, Content Model, Content Type ) below defined briefly

Organization:: An Organization is the first-level entity in Contentful and is typically associated with a company, team, or business

Example: If your business is a large corporation, the organization would represent the entire company, and you could have separate spaces for different departments or projects.

Space::  A Space is a self-contained area within an organization where content is created, managed, and published

Organization -> Space

Example: You might have one space for a corporate website, another for a mobile app, and a third for a product blog. Each of these spaces would have its own content and settings but belong to the same organization.

Content Model:: A Content Model defines the structure of content within a space. It outlines how content types are connected and what fields they contain, It consists of different content types, each representing a specific kind of content, and the fields

Organization -> Space -> Content Model

Example: In a content model for a blog, you might define content types for “Blog Post,” “Author,” and “Category,” with specific fields (such as title, body text, image, etc.) for each content type.

Content Type:: Content types are components of the content model and define which data type can be entered. It defines the fields and structure of a specific type of content

Organization -> Space -> Content Model -> Content Type

Example: For a blog site, you might have the following content types:

Blog Post: Fields could include title, body, author, publish date, and featured image.
Author: Fields could include name, bio, and profile picture.
Category: Fields could include category name and description.

How Organization, Space, Content Model, Content Type Interrelated

Organization contains Spaces, and within each space, you define your Content Models.

A Content Model is made up of multiple Content Types.

Each Content Type defines the structure for individual content entries (like a blog post, author, or product).

What Are Milestones in Software Projects?
Milestones in software projects are significant points or events in the project timeline that mark the completion of major phases, deliverables, or decision points. They are used to track progress, assess project health, and provide checkpoints for stakeholders to evaluate whether the project is on track. Milestones are not tasks or activities themselves, but rather indicators that a set of related tasks has been completed.

Characteristics of Milestones:
Significant Events: Represent critical points in the project, such as the completion of a key deliverable, the start or end of a phase, or a major decision point.
Non-Duration: Unlike tasks, milestones do not have a duration; they simply mark the completion of an event.
Measurable: Milestones are often tied to specific, measurable outcomes (e.g., “Prototype completed” or “Beta version released”).
Critical for Stakeholder Communication: Serve as communication points with stakeholders to review progress and make decisions.

Common Examples of Milestones in Software Projects:

Project Kickoff: The official start of the project.

Project Requirements Completed: All project requirements have been gathered and approved.

Project Plan & Design Approval: Completion and approval of the software design.

Project Resource Allocation: Allocation of resources like team members, tools, and budget.

Project Development Milestones: Completion of major development phases (e.g., “Module A completed,” “Feature X implemented”).

Testing Phase Start/End: Beginning or completion of the testing phase, including unit testing, integration testing, and user acceptance testing (UAT).

Unit Testing: Completion of unit tests for individual components.
Integration Testing: Completion of tests to ensure different components work together.
User Acceptance Testing (UAT): When the end-users test the software to ensure it meets their needs.

Beta Release: The release of a beta version of the software for external testing or limited customer use.

Go-Live: The official launch of the software.

Project Closure: The formal conclusion of the project, including final documentation and retrospective.
How to Set Milestones in Software Projects

Define Project Scope and Objectives: Start by clearly understanding the project’s goals, deliverables, and overall scope. Milestones should align with these objectives and represent critical achievements necessary to complete the project.

Break Down the Project into Phases: Divide the project into logical phases or stages (e.g., planning, design, development, testing, deployment). Identify key deliverables or outputs for each phase.

Identify Key Deliverables: For each phase, identify the major deliverables that must be completed. These deliverables often serve as natural milestones.

Set Milestones for Critical Decision Points: Identify points in the project where significant decisions must be made (e.g., design approval, go/no-go decision). Set milestones at these decision points.

Consult with Stakeholders: Engage with stakeholders (e.g., project sponsors, team members, clients) to ensure that the milestones reflect their expectations and are aligned with business objectives.

Ensure Milestones Are SMART:

Specific: Clearly define what the milestone represents.
Measurable: Ensure that you can objectively verify when the milestone has been achieved.
Achievable: Set realistic milestones that the team can reach.
Relevant: Milestones should be directly related to the project’s goals.
Time-bound: Assign a target date for each milestone.

Integrate Milestones into the Project Plan: Incorporate the milestones into the project timeline using project management tools like Gantt charts, which visually represent when each milestone is expected to occur.

Communicate Milestones to the Team: Ensure that the project team understands the significance of each milestone and what is required to achieve it.

Monitor and Adjust Milestones as Needed: Regularly track progress against milestones during project reviews. If project conditions change, adjust milestones accordingly to keep the project on track.

Celebrate Milestone Achievements: Recognize and celebrate when milestones are reached. This boosts team morale and provides a sense of accomplishment.

Tools for Tracking Milestones: Gantt Charts: Visualize project timelines and milestones.

Project Management Software: Tools like Jira, Trello, Asana, or Microsoft Project allow you to set, track, and update milestones.

Calendar Integration: Sync milestones with calendar tools to remind the team of upcoming key dates.

Importance of Milestones:
Progress Tracking: Helps in assessing whether the project is on schedule.
Risk Management: Early identification of delays or issues if milestones are not met.
Stakeholder Communication: Provides clear points to report progress to stakeholders.
Team Motivation: Milestones can serve as motivational goals for the project team.

Setting and tracking milestones effectively ensures that a software project remains aligned with its goals and timelines, helping to manage risk and maintain stakeholder confidence.

The following below between Microservices Architecture & Monolithic Architecture of Software

Topic	Monolithic Architecture	Microservices Architecture
Services	Monolithic architecture involves typical applications deployed as tightly coupled services	Microservices architecture involves Complex big applications deployed independently as loosely coupled services
Complexity	Simpler in the early stages but can become highly complex and unwieldy as the application grows, all developers responsible for single code base, if any modification required, entire application need to be deployed.	Designed for complex big project & distributed into multiple smaller application to do ease of coding & independently deployment(each single or smaller application).
Use Cases	Best suited for small to medium-sized applications with relatively simple business logic. It is for startups and projects in early stages where speed of development is critical, and the team is small.	Best suited for large, complex applications that require high scalability, frequent updates, and a distributed team structure. Commonly used by large enterprises and companies with complex business needs, like Amazon, Netflix, and Uber.
Testing	Testing can be more straightforward since everything is in one place. However, as the application grows, the complexity of testing increases, particularly with integration and end-to-end tests.	Testing is more complex as each service must be tested independently, as well as in integration with other services. Tools and strategies like contract testing, consumer-driven contracts, and test automation are often required.
Performance	Performance can be optimized more easily within a monolithic architecture because there’s no need for network communication between components.	Performance can be optimized more easily within a microservices architecture, the advantage of scaling individual components, the need for network communication between services can introduce latency and overhead. Optimizing performance requires careful design to manage inter-service communication efficiently.
Maintenance and Updates	Maintenance can become more challenging as the application grows. Updates, especially those involving major changes, can be risky because they affect the entire system	Maintenance is generally easier since individual services can be updated, replaced, or rewritten without affecting the entire system. However, maintaining multiple services can also introduce its own complexity, especially in managing service dependencies.
Fault Isolation	A failure in one part of the application can potentially bring down the entire system. Since everything is interconnected, debugging and resolving issues can be more complex and riskier.	Failures are often isolated to individual services, minimizing the impact on the entire system. For example, if the payment service fails, it doesn’t necessarily bring down the order management service.

1. What is Magento 2 and how does it differ from Magento 1?

• Answer: Magento 2 is the latest version of the Magento eCommerce platform, offering improved performance, scalability, and new features compared to Magento 1. Key differences include:
  • Architecture: Magento 2 has a more modular codebase with a modern tech stack.
  • Performance: Improved indexing, caching, and optimized checkout process.
  • User Experience: Responsive design and better admin interface.
  • Database: Supports multiple databases for different functions (e.g., checkout, orders, and product data).
  • Extensions: Simplified integration with third-party extensions and APIs.

2. Can you explain the Magento 2 architecture?

• Answer: Magento 2 architecture is based on a modular system, separating code into individual modules. The architecture includes:
  • Presentation Layer: Contains blocks, layouts, and templates.
  • Service Layer: Provides a set of interfaces and service contracts.
  • Domain Layer: Business logic, typically found in models.
  • Data Layer: Database access, repository pattern, and entities.
  • Integration Layer: APIs, web services, and external system integrations.
  • Dependency Injection (DI): Magento 2 uses DI to manage class dependencies, improving testability and flexibility.
  • Event-Observer and Plugins: Allows customization and extension of core functionalities.

3. What is Dependency Injection in Magento 2? How does it work?

• Answer: Dependency Injection (DI) is a design pattern used in Magento 2 to manage object dependencies. It allows objects to be passed to other objects through constructors or setters, rather than creating instances directly. This increases flexibility and makes the system more testable.
  • How it works: Magento 2 uses an XML-based configuration to declare dependencies. The DI framework automatically injects the required dependencies when an object is instantiated.

4. How do you manage caching in Magento 2?

• Answer: Magento 2 uses several types of caching to improve performance, including:
  • Configuration Cache: Caches system configuration.
  • Page Cache: Caches full page content (supports Varnish).
  • Block Cache: Caches individual blocks.
  • Collection Cache: Caches database queries.
  • Session Cache: Stores session data.
  • Caches can be managed through the Magento Admin Panel under “System > Cache Management” or via the CLI using bin/magento cache:enable/disable/clean/flush commands.

5. Explain the concept of Service Contracts in Magento 2.

• Answer: Service Contracts are a set of PHP interfaces used to define the APIs (Application Programming Interfaces) of the business logic in Magento 2. They provide a stable API, ensuring backward compatibility and are designed to be used by modules, web services, or third-party developers.
  • Key Components:
    • Data Interfaces: Define the structure of the data (e.g., CustomerInterface, OrderInterface).
    • Service Interfaces: Define operations related to the business logic (e.g., CustomerRepositoryInterface, ProductRepositoryInterface).

6. What is the purpose of Composer in Magento 2?

• Answer: Composer is a dependency manager used in Magento 2 to manage PHP libraries, modules, and dependencies. It helps in:
  • Dependency Management: Automatically installs and updates packages and libraries that Magento or its modules depend on.
  • Autoloading: Composer provides autoloading for classes, reducing the need to manually include files.
  • Version Control: Manages version control of dependencies, ensuring compatibility between modules and core Magento functionality.

7. How do you approach customization in Magento 2?

• Answer: Customization in Magento 2 should follow best practices to ensure maintainability and upgradability:
  • Using Plugins: Allows you to modify the behavior of public methods in a class without overriding the entire class.
  • Observers: Listen to events and execute code when the event is triggered.
  • Overrides: Use carefully to avoid conflicts, usually by creating custom modules rather than directly modifying core files.
  • Layouts and Templates: Customizing the presentation layer using XML layout files and PHTML templates.
  • Service Contracts: Prefer using service contracts for business logic changes to maintain a stable API.

8. What are Magento 2 modules and how do you create one?

• Answer: Magento 2 modules are the building blocks of a Magento application. They contain the code needed to add features or functionality. To create a module:
  • 1. Create the module directory structure:
    • app/code/VendorName/ModuleName
  • 2. Create the module’s registration.php file to register the module with Magento.
  • 3. Create the module.xml file in etc folder to define module details.
  • 4. Configure composer.json to manage dependencies.
  • 5. Define necessary configurations in etc (e.g., routes, events, di.xml).
  • 6. Run bin/magento setup:upgrade to install the module.

9. How do you manage security in a Magento 2 application?

• Answer: Security in Magento 2 can be managed through:
  • Applying Patches: Regularly apply security patches provided by Magento.
  • Two-Factor Authentication (2FA): Enable 2FA for the admin panel.
  • Secure Admin URLs: Change the default admin URL and limit access by IP.
  • Use HTTPS: Enforce HTTPS for all frontend and backend operations.
  • Role-Based Access Control: Create specific user roles and permissions to limit access to sensitive areas.
  • Data Sanitization: Always sanitize user input and use Magento’s built-in methods to avoid SQL injection, XSS, and other attacks.

10. Explain the role of Magento 2 CLI.

• Answer: Magento 2 Command Line Interface (CLI) provides a set of commands to perform various tasks, including:
  • Setup and Configuration: bin/magento setup:install, bin/magento config:set.
  • Cache Management: bin/magento cache:clean, bin/magento cache:flush.
  • Module Management: bin/magento module:enable, bin/magento module:disable.
  • Index Management: bin/magento indexer:reindex.
  • Deployment: bin/magento setup:upgrade, bin/magento deploy:mode:set.

11. What is Varnish and how is it used in Magento 2?

• Answer: Varnish is a web application accelerator (cache) used to improve website performance by caching content and serving it directly from memory. In Magento 2:
  • Full Page Cache (FPC): Varnish can be used as the FPC, reducing the load on the web server and speeding up page delivery.
  • Configuration: Varnish can be configured in Magento 2 under Stores > Configuration > Advanced > System > Full Page Cache.
  • Integration: Magento 2 provides VCL (Varnish Configuration Language) files to integrate Varnish, which can be customized according to the environment.

12. How do you optimize performance in Magento 2?

• Answer: Optimizing performance in Magento 2 involves:
  • Caching: Use Varnish for FPC, enable Redis for session and cache storage.
  • Indexing: Set indexers to “Update on Schedule” for better performance.
  • Optimization Tools: Use tools like Minify HTML/CSS/JS and merge CSS/JS files.
  • CDN: Use a Content Delivery Network to deliver content faster to users.
  • Database Optimization: Regularly clean logs, optimize database tables, and use proper indexes.
  • Image Optimization: Compress images and use responsive images to reduce load time.
  • Server Configuration: Ensure proper server resources (CPU, memory), PHP version (7.4+), and enable OPcache.

13. What is the Magento 2 Layout XML and how does it work?

• Answer: Layout XML in Magento 2 is used to define the structure and content of a page. It controls which blocks are displayed, in what order, and where.
  • Key Elements:
    • <block>: Defines a block of content.
    • <container>: Defines a container that can hold blocks.
    • <referenceBlock> and <referenceContainer>: Modify existing blocks/containers.
    • <remove>: Removes blocks or containers.
  • Usage: Layout XML is defined in module or theme specific XML files, such as default.xml, catalog_product_view.xml, etc.

14. How do you handle multi-store functionality in Magento 2?

• Answer: Magento 2’s multi-store functionality allows you to manage multiple websites, stores, and store views from a single Magento installation.