Curriculum &
Program Details

What you'll build

• Build a responsive business website with a registration form, navigation bar, data table, and JavaScript-based form validation.

What you'll build

• Develop a business dashboard with login, employee listing, employee registration, editing forms, navigation, search, and filtering.

What you'll build

• Develop a backend application with employee registration, employee retrieval, updating, and deletion endpoints.

What you'll build

• Design a database for an Employee Management System with employees, departments, and roles. Write queries and integrate the database with the backend.

What you'll build

• Integrate the React frontend with the Node.js backend and MySQL database. Implement complete employee CRUD functionality with search and pagination.

What you'll build

• Implement login and role-based access for administrators, managers, and employees. Verify that restricted operations cannot be accessed without appropriate permissions.

What you'll build

• Write tests for employee CRUD APIs, invalid form inputs, unauthorised requests, and important application workflows. Debug and fix identified defects.

What you'll build

• Create a shared project repository, assign features to team members, develop them in separate branches, review pull requests, and merge approved changes.

What you'll build

• Create basic REST API endpoints using Express.js, test them using Postman, and connect the APIs to a React frontend to retrieve and display data.

What you'll build

• Develop an Express application with separate modules for:
• Employees
• Departments
• Users
• Authentication
• Reports
• Deliverable
• A structured Express.js backend with reusable middleware, organised routes, and centralised error handling.

What you'll build

• Create and document APIs for:
• Employee management
• Department management
• User authentication
• Search and filtering
• Reporting
• Deliverable
• A documented REST API with tested endpoints and consistent response formats.

What you'll build

• Create a database with:
• Employees
• Departments
• Roles
• Users
• Leave requests
• Audit records
• Write queries for employee search, department-wise reports, leave summaries, and management dashboards.
• Deliverable
• A relational database with an ER diagram, constraints, and a collection of business-oriented SQL queries.

What you'll build

• Connect the Express application to MySQL and implement employee CRUD APIs with:
• Database migrations
• Seed data
• Validation
• Relationships
• Error handling
• Transactional business operations
• Deliverable
• A functioning backend connected to MySQL with controlled schema migrations and reliable data access.
• MODULE 14A: PYTHON BACKEND DEVELOPMENT
• Objective
• Develop REST APIs and backend services using Python and a suitable Python web framework.
• Topics Covered
• Python backend project setup and virtual environments
• Python fundamentals required for backend development
• Choosing an appropriate framework: Django, Flask, or FastAPI
• Project structure and configuration
• Routing and request-response handling
• HTTP methods and status codes
• Path parameters, query parameters, and request bodies
• JSON responses and data validation
• Building REST API endpoints
• Business logic and separation of concerns
• Error handling and logging
• Environment variables and secret management
• Connecting Python applications to MySQL
• Database drivers and ORM concepts
• CRUD operations
• Parameterised queries and SQL injection prevention
• Authentication and authorisation fundamentals
• API documentation
• Unit and integration testing
• Running the application in development and production environments
• Build a Python backend for the employee management system.
• Implement employee and department CRUD endpoints.
• Connect the backend to the existing MySQL schema.
• Validate requests and handle errors consistently.
• Test endpoints using Postman.
• Document the API and setup instructions.
• Deliverable
• A tested Python REST API integrated with MySQL and ready to connect to the React frontend.
• MODULE 14B: PHP BACKEND DEVELOPMENT
• Objective
• Develop REST APIs and backend services using PHP, with Laravel as the recommended framework for structured application development.
• Topics Covered
• PHP installation and development environment setup
• PHP syntax, variables, data types, operators, and control flow
• Functions, arrays, and string handling
• Object-oriented PHP: classes, objects, inheritance, interfaces, and traits
• Composer and dependency management
• PHP project structure
• Laravel fundamentals and project setup
• Routing and controllers
• Request and response handling
• REST API endpoints
• Middleware and request validation
• Environment configuration using .env
• Error handling and logging
• Connecting PHP/Laravel to MySQL
• Models, migrations, and database seeders
• CRUD operations using Laravel's database tools or ORM
• Relationships and database transactions
• Authentication and authorisation fundamentals
• API documentation
• Unit and feature testing
• Secure handling of credentials and application configuration
• Build a PHP/Laravel backend for the employee management system.
• Implement employee and department CRUD endpoints.
• Connect the backend to the existing MySQL schema.
• Validate requests and return consistent API responses.
• Test endpoints using Postman.
• Document the API and setup instructions.
• Deliverable
• A tested PHP/Laravel REST API integrated with MySQL and ready to connect to the React frontend.
• Backend Track Selection Note
• The course does not require participants to implement the same backend in all three technologies. The organisation or project team can select Node.js/Express.js, Python, or PHP/Laravel as the primary backend track. If time permits, the other tracks can be taught as optional extensions.
• SECURITY, TESTING, AND SOFTWARE QUALITY

What you'll build

• Implement authentication and roles for:
• Administrator
• Manager
• Employee
• Ensure that sensitive operations are authorised by the backend.
• Deliverable
• A full-stack application with working login, logout, and role-based permissions.

What you'll build

• Build a responsive business website with a registration form, navigation bar, data table, and JavaScript-based form validation.

What you'll build

• Develop a business dashboard with login, employee listing, employee registration, editing forms, navigation, search, and filtering.

What you'll build

• Develop a backend application with employee registration, employee retrieval, updating, and deletion endpoints.

What you'll build

• Design a database for an Employee Management System with employees, departments, and roles. Write queries and integrate the database with the backend.

What you'll build

• Integrate the React frontend with the Node.js backend and MySQL database. Implement complete employee CRUD functionality with search and pagination.

What you'll build

• Implement login and role-based access for administrators, managers, and employees. Verify that restricted operations cannot be accessed without appropriate permissions.

What you'll build

• Write tests for employee CRUD APIs, invalid form inputs, unauthorised requests, and important application workflows. Debug and fix identified defects.

What you'll build

• Create a shared project repository, assign features to team members, develop them in separate branches, review pull requests, and merge approved changes.

What you'll build

• Create basic REST API endpoints using Express.js, test them using Postman, and connect the APIs to a React frontend to retrieve and display data.

What you'll build

• Develop an Express application with separate modules for:
• Employees
• Departments
• Users
• Authentication
• Reports
• Deliverable
• A structured Express.js backend with reusable middleware, organised routes, and centralised error handling.

What you'll build

• Create and document APIs for:
• Employee management
• Department management
• User authentication
• Search and filtering
• Reporting
• Deliverable
• A documented REST API with tested endpoints and consistent response formats.

What you'll build

• Create a database with:
• Employees
• Departments
• Roles
• Users
• Leave requests
• Audit records
• Write queries for employee search, department-wise reports, leave summaries, and management dashboards.
• Deliverable
• A relational database with an ER diagram, constraints, and a collection of business-oriented SQL queries.

What you'll build

• Connect the Express application to MySQL and implement employee CRUD APIs with:
• Database migrations
• Seed data
• Validation
• Relationships
• Error handling
• Transactional business operations
• Deliverable
• A functioning backend connected to MySQL with controlled schema migrations and reliable data access.
• MODULE 14A: PYTHON BACKEND DEVELOPMENT
• Objective
• Develop REST APIs and backend services using Python and a suitable Python web framework.
• Topics Covered
• Python backend project setup and virtual environments
• Python fundamentals required for backend development
• Choosing an appropriate framework: Django, Flask, or FastAPI
• Project structure and configuration
• Routing and request-response handling
• HTTP methods and status codes
• Path parameters, query parameters, and request bodies
• JSON responses and data validation
• Building REST API endpoints
• Business logic and separation of concerns
• Error handling and logging
• Environment variables and secret management
• Connecting Python applications to MySQL
• Database drivers and ORM concepts
• CRUD operations
• Parameterised queries and SQL injection prevention
• Authentication and authorisation fundamentals
• API documentation
• Unit and integration testing
• Running the application in development and production environments
• Build a Python backend for the employee management system.
• Implement employee and department CRUD endpoints.
• Connect the backend to the existing MySQL schema.
• Validate requests and handle errors consistently.
• Test endpoints using Postman.
• Document the API and setup instructions.
• Deliverable
• A tested Python REST API integrated with MySQL and ready to connect to the React frontend.
• MODULE 14B: PHP BACKEND DEVELOPMENT
• Objective
• Develop REST APIs and backend services using PHP, with Laravel as the recommended framework for structured application development.
• Topics Covered
• PHP installation and development environment setup
• PHP syntax, variables, data types, operators, and control flow
• Functions, arrays, and string handling
• Object-oriented PHP: classes, objects, inheritance, interfaces, and traits
• Composer and dependency management
• PHP project structure
• Laravel fundamentals and project setup
• Routing and controllers
• Request and response handling
• REST API endpoints
• Middleware and request validation
• Environment configuration using .env
• Error handling and logging
• Connecting PHP/Laravel to MySQL
• Models, migrations, and database seeders
• CRUD operations using Laravel's database tools or ORM
• Relationships and database transactions
• Authentication and authorisation fundamentals
• API documentation
• Unit and feature testing
• Secure handling of credentials and application configuration
• Build a PHP/Laravel backend for the employee management system.
• Implement employee and department CRUD endpoints.
• Connect the backend to the existing MySQL schema.
• Validate requests and return consistent API responses.
• Test endpoints using Postman.
• Document the API and setup instructions.
• Deliverable
• A tested PHP/Laravel REST API integrated with MySQL and ready to connect to the React frontend.
• Backend Track Selection Note
• The course does not require participants to implement the same backend in all three technologies. The organisation or project team can select Node.js/Express.js, Python, or PHP/Laravel as the primary backend track. If time permits, the other tracks can be taught as optional extensions.
• SECURITY, TESTING, AND SOFTWARE QUALITY

What you'll build

• Implement authentication and roles for:
• Administrator
• Manager
• Employee
• Ensure that sensitive operations are authorised by the backend.
• Deliverable
• A full-stack application with working login, logout, and role-based permissions.

What you'll build

• Inspect the network requests of an existing website.
• Identify frontend assets and API calls using browser tools.
• Draw a basic frontend-backend-database architecture diagram.
• Write a simple requirement document for an employee management application.
• Deliverable
• A basic project requirement document and an architecture diagram.

What you'll build

• Build the following:
• Personal portfolio page
• Employee registration form
• Employee information table
• Login and registration interface
• Basic business dashboard structure
• Deliverable
• A multi-page HTML application with semantic structure and accessible forms.

What you'll build

• Build a responsive employee dashboard containing:
• Navigation bar
• Sidebar
• Dashboard cards
• Employee table
• Search and filter controls
• Registration form
• Responsive mobile layout
• Deliverable
• A responsive business dashboard that works across supported desktop, tablet, and mobile screen sizes.

What you'll build

• Create a calculator.
• Build a task management application.
• Implement employee search and filtering.
• Validate registration forms.
• Retrieve data from a public test API.
• Display API data with loading and error states.
• Build a basic expense tracker using browser storage.
• Deliverable
• A functional JavaScript application with interactive components, data manipulation, and API integration.

What you'll build

• Convert selected JavaScript functions to TypeScript.
• Define employee and department interfaces.
• Create type-safe validation functions.
• Model API response types.
• Fix type errors in a sample project.
• Deliverable
• A small TypeScript application with strict type checking, linting, and consistent formatting.
• REACT FRONTEND DEVELOPMENT

What you'll build

• Create reusable components for:
• Employee cards
• Employee tables
• Search fields
• Status badges
• Navigation bars
• Dashboard summary cards
• Forms and confirmation dialogs
• Deliverable
• A component-based React employee directory.

What you'll build

• Create the following pages:
• Login
• Dashboard
• Employee listing
• Employee details
• Add employee
• Edit employee
• Department listing
• Not-found page
• Deliverable
• A multi-page React business application with reusable components, routing, and validated forms.

What you'll build

• Connect the employee directory to a test API and implement:
• Employee listing
• Employee creation
• Employee updates
• Employee deletion
• Search
• Filtering
• Pagination
• Loading and error states
• Deliverable
• A React application integrated with an API and equipped with consistent request handling.

What you'll build

• Refactor a single-file React application into feature-based modules. Implement reusable hooks, centralised API handling, and improved loading and error states.
• Deliverable
• A maintainable React frontend with a documented folder structure and consistent coding standards.
• BACKEND DEVELOPMENT, REST APIs, AND MYSQL

What you'll build

• Create a basic Node.js server.
• Build a command-line utility.
• Read and validate JSON data.
• Implement asynchronous operations.
• Handle invalid input and runtime errors.
• Deliverable
• A modular Node.js application with organised files, error handling, and configuration.

What you'll build

• Develop an Express application with separate modules for:
• Employees
• Departments
• Users
• Authentication
• Reports
• Deliverable
• A structured Express.js backend with reusable middleware, organised routes, and centralised error handling.

What you'll build

• Create and document APIs for:
• Employee management
• Department management
• User authentication
• Search and filtering
• Reporting
• Deliverable
• A documented REST API with tested endpoints and consistent response formats.

What you'll build

• Create a database with:
• Employees
• Departments
• Roles
• Users
• Leave requests
• Audit records
• Write queries for employee search, department-wise reports, leave summaries, and management dashboards.
• Deliverable
• A relational database with an ER diagram, constraints, and a collection of business-oriented SQL queries.

What you'll build

• Connect the Express application to MySQL and implement employee CRUD APIs with:
• Database migrations
• Seed data
• Validation
• Relationships
• Error handling
• Transactional business operations
• Deliverable
• A functioning backend connected to MySQL with controlled schema migrations and reliable data access.
• MODULE 14A: PYTHON BACKEND DEVELOPMENT
• Objective
• Develop REST APIs and backend services using Python and a suitable Python web framework.
• Topics Covered
• Python backend project setup and virtual environments
• Python fundamentals required for backend development
• Choosing an appropriate framework: Django, Flask, or FastAPI
• Project structure and configuration
• Routing and request-response handling
• HTTP methods and status codes
• Path parameters, query parameters, and request bodies
• JSON responses and data validation
• Building REST API endpoints
• Business logic and separation of concerns
• Error handling and logging
• Environment variables and secret management
• Connecting Python applications to MySQL
• Database drivers and ORM concepts
• CRUD operations
• Parameterised queries and SQL injection prevention
• Authentication and authorisation fundamentals
• API documentation
• Unit and integration testing
• Running the application in development and production environments
• Build a Python backend for the employee management system.
• Implement employee and department CRUD endpoints.
• Connect the backend to the existing MySQL schema.
• Validate requests and handle errors consistently.
• Test endpoints using Postman.
• Document the API and setup instructions.
• Deliverable
• A tested Python REST API integrated with MySQL and ready to connect to the React frontend.
• MODULE 14B: PHP BACKEND DEVELOPMENT
• Objective
• Develop REST APIs and backend services using PHP, with Laravel as the recommended framework for structured application development.
• Topics Covered
• PHP installation and development environment setup
• PHP syntax, variables, data types, operators, and control flow
• Functions, arrays, and string handling
• Object-oriented PHP: classes, objects, inheritance, interfaces, and traits
• Composer and dependency management
• PHP project structure
• Laravel fundamentals and project setup
• Routing and controllers
• Request and response handling
• REST API endpoints
• Middleware and request validation
• Environment configuration using .env
• Error handling and logging
• Connecting PHP/Laravel to MySQL
• Models, migrations, and database seeders
• CRUD operations using Laravel's database tools or ORM
• Relationships and database transactions
• Authentication and authorisation fundamentals
• API documentation
• Unit and feature testing
• Secure handling of credentials and application configuration
• Build a PHP/Laravel backend for the employee management system.
• Implement employee and department CRUD endpoints.
• Connect the backend to the existing MySQL schema.
• Validate requests and return consistent API responses.
• Test endpoints using Postman.
• Document the API and setup instructions.
• Deliverable
• A tested PHP/Laravel REST API integrated with MySQL and ready to connect to the React frontend.
• Backend Track Selection Note
• The course does not require participants to implement the same backend in all three technologies. The organisation or project team can select Node.js/Express.js, Python, or PHP/Laravel as the primary backend track. If time permits, the other tracks can be taught as optional extensions.
• SECURITY, TESTING, AND SOFTWARE QUALITY

What you'll build

• Implement authentication and roles for:
• Administrator
• Manager
• Employee
• Ensure that sensitive operations are authorised by the backend.
• Deliverable
• A full-stack application with working login, logout, and role-based permissions.

What you'll build

• Conduct a security review of the employee management application. Identify insecure queries, weak access controls, exposed credentials, and inappropriate error responses.
• Deliverable
• A security checklist and a remediated application with documented findings.

What you'll build

• Write automated tests for employee CRUD, invalid input, duplicate records, unauthorised access, and complete browser-based workflows.
• Deliverable
• An automated test suite covering critical frontend, backend, and end-to-end workflows.

What you'll build

• Investigate a prepared application containing frontend defects, backend exceptions, database errors, and authorisation issues. Fix the issues and submit a reviewed pull request.
• Deliverable
• A defect report, corrected code, and a documented code review.

What you'll build

• Conduct a simulated two-week sprint. Assign tasks, create branches, submit pull requests, resolve conflicts, review code, and merge approved changes.
• Deliverable
• A team repository with structured branches, reviewed changes, issue tracking, and sprint documentation.
• DEVOPS, CI/CD, AND DEPLOYMENT

What you'll build

• Configure separate local and staging environments with different API URLs and database credentials. Validate required settings at application startup.
• Deliverable
• A documented configuration system that separates environment-specific settings and protects secrets.

What you'll build

• Containerise:
• React frontend
• Express backend
• MySQL database
• Configure the application using Docker Compose and document startup, shutdown, and troubleshooting procedures.
• Deliverable
• A containerised full-stack application that can be started consistently on another developer's machine.

What you'll build

• Build a pipeline that:
• Runs on pull requests.
• Installs dependencies.
• Runs linting and type checks.
• Executes automated tests.
• Builds the frontend and backend.
• Builds a container image when appropriate.
• Deploys to a staging environment after the required checks.
• Deliverable
• A working CI/CD pipeline with automated validation and a controlled staging deployment.

What you'll build

• Deploy the application to a staging environment, configure HTTPS, connect the database securely, run smoke tests, inspect logs, and document rollback steps.
• Deliverable
• A deployed application with documented configuration, verification, monitoring, and recovery procedures.
• INDUSTRIAL PROJECT DEVELOPMENT AND CLIENT DELIVERY

What you'll build

• Load-test selected API endpoints, investigate slow database queries, improve application performance, and document the results.
• Deliverable
• A performance and production-readiness report containing test scenarios, findings, improvements, and known limitations.

What you'll build

• AND ASSESSMENT MODEL
• The programme should emphasise practical implementation instead of relying exclusively on theoretical explanations.
• Suggested Assessment Distribution
• Technical concepts and quizzes — 10%
• Coding exercises and weekly assignments — 20%
• Module-wise practical assessments — 20%
• Mini-projects — 15%
• Code quality, Git workflow, and testing — 10%
• Final industrial capstone project — 25%
• Total: 100%
• Assessment criteria can be adjusted based on the organisation's training policies.
• Weekly Assessment Activities
• Coding exercises
• Debugging exercises
• SQL query assignments
• API implementation tasks
• Frontend component development
• Peer code reviews
• Git workflow exercises
• Test-case creation
• Short technical demonstrations
• Documentation assignments
• CORPORATE DEVELOPMENT STANDARDS
• All projects developed during the programme should follow these practices.
• Code Quality
• Use consistent naming conventions.
• Keep components and functions focused.
• Separate business logic from presentation.
• Use linting and formatting tools.
• Avoid unnecessary code duplication.
• Document important architectural decisions.
• Version Control
• Maintain a shared repository.
• Use feature branches and pull requests.
• Review changes before merging.
• Never commit passwords, tokens, or production credentials.
• Link significant changes to project tasks.
• Database Management
• Use primary and foreign keys appropriately.
• Apply constraints for data integrity.
• Use parameterised queries.
• Version-control schema migrations.
• Restrict database permissions.
• Maintain suitable backup and recovery procedures.
• API Development
• Validate all incoming data.
• Use appropriate HTTP methods and status codes.
• Return consistent error responses.
• Document API contracts.
• Enforce authentication and authorisation where required.
• Avoid exposing sensitive information.
• Testing
• Test critical business workflows.
• Include negative and boundary cases.
• Automate repeatable tests.
• Run relevant checks before merging and releasing.
• Record defects and verify fixes.
• Security
• Follow secure coding practices.
• Store secrets using approved mechanisms.
• Use HTTPS in production.
• Apply least-privilege access.
• Review dependencies and permissions.
• Protect sensitive data in application logs.
• Deployment
• Keep development, testing, staging, and production environments appropriately separated.
• Automate repeatable build and validation tasks.
• Apply controlled production approvals.
• Verify deployments with smoke tests.
• Maintain recovery and rollback procedures.
• Documentation
• Maintain a README and setup guide.
• Document APIs and database schemas.
• Keep deployment instructions current.
• Document known limitations.
• Provide handover and operational support information.
• EXPECTED OUTCOMES
• After successfully completing the training programme and capstone, participants should be able to:
• Understand client requirements and convert them into technical tasks.
• Build responsive user interfaces using HTML, CSS, JavaScript, TypeScript, and React.
• Develop structured backend applications using Node.js and Express.js.
• Develop REST APIs using Python and a suitable framework such as Django, Flask, or FastAPI.
• Develop REST APIs using PHP and Laravel.
• Design relational databases using MySQL.
• Write SQL queries, joins, aggregations, and transactions.
• Develop and document REST APIs.
• Integrate frontend applications with backend services.
• Implement authentication and role-based authorisation.
• Apply common secure coding practices.
• Write unit, integration, and end-to-end tests.
• Debug application and database issues.
• Use Git-based collaboration and code-review workflows.
• Apply maintainable architecture and coding standards.
• Containerise applications using Docker.
• Implement basic CI/CD pipelines.
• Deploy applications to a suitable staging environment.
• Read logs and investigate application errors.
• Understand performance and reliability fundamentals.
• Prepare technical documentation and project handover material.
• Demonstrate a complete client-style application.
• FINAL COURSE COMPLETION CRITERIA
• A participant should be considered to have successfully completed the programme when they can:
• Explain the architecture of their application.
• Demonstrate the core business workflows.
• Show that the frontend, backend, and database work together.
• Demonstrate authentication and server-side permissions.
• Run the automated tests and explain their purpose.
• Use Git and explain the pull-request workflow.
• Start the application using the documented setup instructions.
• Explain the deployment process.
• Investigate a basic application failure using logs.
• Present the project and answer technical questions.
• Provide the source code and required documentation.
• FINAL PROGRAMME GOAL
• Prepare participants to contribute to real corporate and client projects as junior full-stack developers who understand not only how to write code, but also how to collaborate, test, secure, deploy, document, and maintain software.

What you'll build

• Prepare an SRS for an Employee Management System that includes employee registration, authentication, role-based access, employee records, search, leave management, and reporting.

What you'll build

• Convert the Employee Management System requirements into epics, user stories, development tasks, acceptance criteria, and a two-week sprint plan.

What you'll build

• Trace a login request from a React page to the Node.js backend, inspect the server response, and explain how the backend retrieves and verifies the user's data.

What you'll build

• Build a responsive employee dashboard containing a navigation bar, sidebar, employee table, search field, filters, form, and summary cards.

What you'll build

• Implement a type-safe employee data model, filter employee records, validate function inputs, and handle asynchronous data retrieval.

What you'll build

• Create reusable components for employee cards, tables, search fields, status badges, pagination controls, and employee forms.

What you'll build

• Create separate pages for login, dashboard, employee listing, employee details, add employee, edit employee, and access-denied handling.

What you'll build

• Connect the employee listing page to backend endpoints. Implement employee search, pagination, creation, updating, deletion, loading indicators, and error handling.

What you'll build

• Build an Express backend with separate route, controller, service, and data-access layers for employee management.

What you'll build

• Design and document the employee API, including request schemas, successful responses, validation errors, authentication requirements, and status codes.

What you'll build

• Design a database for an Employee Management System with employees, departments, roles, permissions, and leave requests.

What you'll build

• Write SQL queries for employee search, department-wise counts, leave summaries, salary reports, and paginated employee listings. Use EXPLAIN to investigate a slow query and improve it.

What you'll build

• Connect the Express backend to MySQL. Implement employee CRUD operations, foreign-key relationships, migrations, seed data, and transactional handling for a multi-step business operation.

What you'll build

• Implement login and logout for employee, manager, and administrator roles. Restrict employee records and administrative actions according to permissions.

What you'll build

• Review the application for SQL injection, insecure access controls, exposed secrets, overly permissive CORS, and unsafe error responses. Fix the issues and verify the changes with tests.

What you'll build

• Write tests for employee creation, duplicate employee identifiers, invalid input, unauthorised access, database failures, and a complete browser-based employee creation workflow.

What you'll build

• Create feature branches for employee CRUD, authentication, and reporting. Submit pull requests, review changes, resolve a merge conflict, and merge approved code into the main branch.

What you'll build

• Refactor a large Express controller into route, validation, service, and data-access layers. Refactor duplicated React form logic into reusable components or hooks.

What you'll build

• Configure local, testing, and staging environments with separate database credentials. Ensure secrets are excluded from source control and validate required configuration at application startup.

What you'll build

• Containerise the React application, Express backend, and MySQL database. Use Docker Compose to start the services and document the commands needed to run the application.

What you'll build

• Create a pipeline that runs linting, TypeScript checks, tests, and production builds on pull requests. Configure an approved deployment workflow with protected production approvals.

What you'll build

• Deploy the React frontend and Express backend to a test environment with a managed or securely hosted MySQL database. Configure HTTPS, secrets, health checks, and a rollback procedure.

What you'll build

• Simulate a backend error and a slow database query. Use logs and metrics to identify the cause, apply a fix, verify recovery, and write a short incident report.

What you'll build

• Load-test employee search and reporting endpoints using realistic test data. Identify bottlenecks and compare response times before and after optimisation.

What you'll build

• Create reusable prompts for common frontend and backend development tasks.
• Generate a responsive login page using HTML, CSS, and JavaScript.
• Ask AI to create a backend endpoint and explain how it works.
• Improve an initial prompt to generate cleaner, reusable, and maintainable code.

What you'll build

• Provide a sample full stack project structure and ask AI to explain each folder.
• Analyze a React frontend and identify how it communicates with the backend.
• Examine backend routes and database models to understand application functionality.
• Generate a project overview containing the technology stack, dependencies, API endpoints, and setup steps.

What you'll build

• Analyze an SRS for an employee management web application.
• Extract frontend screens, backend features, and database entities.
• Generate an API requirements list based on the application workflows.
• Identify missing validation, authorization, error-handling, and testing requirements.
• Create a requirement-to-module mapping for implementation.

What you'll build

• Convert an SRS for a student management system into a structured PRD.
• Define user roles, application screens, and major features.
• Generate acceptance criteria for login, student registration, record updates, and search.
• Create a feature-wise implementation plan covering frontend, backend, and database tasks.
• Compare the generated PRD with the original SRS to identify missing requirements.

What you'll build

• Analyze an employee management application requirement and generate clarification questions.
• Prepare client questions for a web application with administrator and employee roles.
• Identify missing details about registration, password recovery, approvals, and reporting.
• Generate a client requirement checklist and meeting summary.
• Convert confirmed answers into updated development tasks.

What you'll build

• Design a full stack architecture for an employee management system.
• Ask AI to recommend an appropriate frontend, backend, and database stack.
• Generate a project folder structure and define responsibilities for each layer.
• Design API endpoints and a database schema for employee records.
• Generate an architecture diagram and initial code scaffolding.
• Review the design for security, maintainability, scalability, and integration risks.

What you'll build

• Given a client requirement for an employee management application, use AI to identify the required React screens, Node.js APIs, MongoDB collections, authentication rules, and acceptance criteria.

What you'll build

• Break down an online shopping application into frontend development, backend APIs, product and order databases, authentication, payment integration, testing, and deployment tasks.

What you'll build

• In an existing application, trace the complete employee registration flow from the React form through the Node.js API to MongoDB and back to the user interface.

What you'll build

• Develop an employee listing page with search, pagination, filtering, loading indicators, error handling, and employee details using AI assistance.

What you'll build

• Improve a dashboard that contains repeated API calls, duplicated loading logic, and inconsistent error handling. Use AI to identify the duplication and implement a reusable solution.

What you'll build

• Integrate a React employee management interface with Node.js APIs for creating, retrieving, updating, and deleting employee records.

What you'll build

• Implement a Node.js employee management API with CRUD operations, input validation, service-layer business logic, consistent errors, and automated tests.

What you'll build

• Analyse a slow employee search API. Use AI to review the MongoDB query, recommend appropriate indexes, and compare query execution before and after the changes.

What you'll build

• Implement a complete leave management feature:
• React form for leave applications.
• Node.js APIs for creating and retrieving requests.
• MongoDB storage for leave records.
• Validation and error handling.
• Manager approval workflow.
• Automated tests.
• Updated API and project documentation.

What you'll build

• Investigate a defect where an employee record is created successfully in MongoDB but the React interface displays an error.
• Use AI to trace the request-response flow and identify the actual problem.

What you'll build

• Generate tests for an employee creation API, including valid requests, invalid email addresses, missing required fields, duplicate records, unauthorised access, and database failures.

What you'll build

• Automate the complete employee registration workflow, including form validation, submission, database persistence verification, and display of the newly created employee record.

What you'll build

• Review a pull request containing duplicated React logic, inconsistent Node.js error handling, an inefficient MongoDB query, and missing test cases.
• Use AI to identify issues and prepare a prioritised review report.

What you'll build

• Review an authentication API and identify possible weaknesses involving password handling, access-control checks, exposed secrets, and unsafe database queries.
• Implement corrections and test that unauthorised requests are rejected.

What you'll build

• Take a full-stack feature branch containing React, Node.js, and MongoDB changes. Use AI to prepare a pull request description, summarise modified files, identify potentially missing tests, and generate a release note.

What you'll build

• Containerise an existing full-stack application and configure the React frontend, Node.js API, and MongoDB development database to run together using Docker Compose.

What you'll build

• Create a CI pipeline that runs when code is pushed or a pull request is opened.
• The pipeline should install dependencies, run linting, execute tests, build the React frontend and Node.js backend as applicable, and prevent merging when mandatory checks fail.

What you'll build

• Deploy a full-stack application to a staging environment using the company's approved hosting platform.
• Automate the build and deployment steps, run post-deployment smoke tests, and verify that the frontend, API, and database work correctly.

What you'll build

• Investigate a production incident in which the Node.js API begins returning intermittent errors while MongoDB response times increase.
• Use AI to correlate the symptoms, propose diagnostic steps, and prepare a root-cause report based on verified evidence.

What you'll build

• Optimise a slow dashboard that loads thousands of records and performs expensive database queries.
• Use AI to identify frontend and backend bottlenecks, improve pagination and query execution, and compare response times before and after the changes.

What you'll build

• Upgrade a project dependency with a breaking API change.
• Use AI to identify affected files, propose the migration, update tests, and prepare a dependency-change report.

What you'll build

• Create a reusable AI-assisted workflow for implementing a full-stack feature. It should inspect the repository, identify relevant files, prepare a plan, implement changes, run tests, review the code diff, and update documentation.