Skip to main content

Prompt Library for Testing & Automation

This comprehensive prompt library contains carefully crafted AI prompts designed specifically for software testing and automation professionals. These prompts are optimized for use with AI tools like ChatGPT, GitHub Copilot, Claude, and other AI assistants to enhance your productivity and code quality.

Table of Contents​

Test Automation Framework Development​

Selenium WebDriver Framework Creation​

Use this prompt to generate a complete, production-ready test automation framework using Selenium WebDriver and Java.

Prompt:

Create a modern, scalable, and modular test automation framework using Java 11 or above and Selenium WebDriver that supports cross-browser testing (Chrome, Firefox, Edge)

Key requirements:
• Use TestNG as the test runner
• Follow Page Object Model (POM) design pattern
• Use Maven for build management
• Implement logging (e.g., Log4j or SLF4J) and reporting (e.g., Extent Reports or Allure or both)
• Parallel test execution support for local and remote tests
• A Base Test setup that initializes browser and platform based on config
• Add a pipeline using Github actions and a it should generate a link to allure and extent report
• README and sample tests to show usage
• Test Data should be separate from logic
• Make it compatible with running on Lambdatest platform
• google.com - this site should be used as a sample site for which test should be written

Add these test scenarios (excluding login scenarios):
• A test to check if none of the links are broken
• A test to check if number of images on screen are more than 1
• Write 3-4 tests for the search engine functionality where some should fail and some should pass

Enjoyed this video?

Watch on YouTube•Subscribe for More•Like and Comment if this helped you!

Browser Automation Prompts​

Smart Locator Generation​

Playwright Locator Generation​

Analyze this webpage and generate Playwright locators using best practices:
- Use getByRole() for interactive elements (buttons, links, inputs)
- Use getByLabel() for form fields with labels
- Use getByTestId() for elements with test-id attributes
- Use getByText() for unique text content
- Provide fallback locators using getByLocator() for complex elements
- Include both positive and negative assertions where applicable
- Format as TypeScript Page Object Model methods

Focus on user-centric locators that are resilient to UI changes.

Selenium WebDriver Locator Scripts​

Generate Selenium WebDriver locators for this page and create a complete Page Object class:
- Use By.id() for elements with unique IDs
- Use By.name() for form elements with name attributes
- Use By.linkText() and By.partialLinkText() for links
- Use By.xpath() only when necessary, prefer CSS selectors
- Include WebDriverWait conditions for dynamic elements
- Add proper error handling and logging
- Format as Java/Python/C# Page Object Pattern
- Include common actions like click(), sendKeys(), getText()

Generate both individual locators and complete interaction methods.

Cross-Browser Compatible Locators​

Create cross-browser compatible locators for this webpage:
- Generate CSS selectors that work across Chrome, Firefox, Safari, and Edge
- Avoid browser-specific pseudo-selectors
- Use stable attributes (data-testid, role, aria-label)
- Provide multiple locator strategies for critical elements
- Include mobile-responsive locator alternatives
- Test locator uniqueness and stability
- Format as JSON object with element descriptions

Prioritize accessibility attributes and semantic HTML elements.

Section-Specific Locator Generation​

Generate locators specifically for the [SECTION_NAME] section of this page:
- Identify the container element for the section
- Map all interactive elements within this section
- Use relative locators from the section container
- Include data validation locators for dynamic content
- Generate both individual element and collection locators
- Provide methods for section-level operations (expand, collapse, filter)
- Format as [FRAMEWORK] Page Object methods with clear naming conventions

Example: For "Candidates" section, include locators for candidate cards, filters, pagination, and search functionality.

AI-Enhanced Locator Strategies​

Analyze this webpage and suggest intelligent locator strategies:
- Identify elements likely to change frequently (dynamic IDs, generated classes)
- Recommend stable alternatives using semantic attributes
- Suggest data-testid placement for untestable elements
- Generate locators with built-in retry mechanisms
- Include accessibility-compliant alternatives
- Provide locator health scoring based on stability factors
- Suggest page structure improvements for better testability

Create self-healing locator patterns that can adapt to minor UI changes.

Playwright with Modern Web Apps​

Generate Playwright locators for this SPA/React/Angular application:
- Use page.locator() with chaining for complex scenarios
- Include page.waitForSelector() for dynamic content
- Generate locators for shadow DOM elements if present
- Use page.frameLocator() for iframe content
- Include network request interception patterns
- Provide locators for handling loading states and animations
- Format with proper async/await patterns and error handling

Include performance-optimized selectors and parallel execution strategies.

Selenium with Dynamic Content​

Create robust Selenium locators for this dynamic webpage:
- Generate explicit waits for all interactive elements
- Include retry mechanisms for flaky elements
- Use ActionChains for complex user interactions
- Generate locators that handle AJAX loading
- Include screenshot capture points for debugging
- Provide data-driven test parameter mapping
- Format with proper exception handling and logging

Focus on elements that load asynchronously or change state frequently.

Cypress Modern Testing​

Generate Cypress commands and locators for this page:
- Use cy.get() with data-cy attributes preferably
- Include custom commands for repeated actions
- Generate intercepts for API calls
- Use proper cy.wait() strategies for dynamic content
- Include viewport and responsive testing locators
- Provide fixture data integration patterns
- Format as reusable command library

Emphasize Cypress best practices and real-world user interaction flows.

Test Data Generation​

Generate realistic test data for this form/application:
- Create valid data sets covering happy path scenarios
- Generate boundary value test cases (min/max values)
- Include negative test data (invalid formats, SQL injection attempts)
- Provide internationalization test data (Unicode, RTL languages)
- Generate accessibility testing data (screen reader compatibility)
- Create performance test data (large datasets, stress testing)
- Format as JSON/CSV/database seed files

Include both positive and negative test scenarios with expected outcomes.

WhatsApp Group Cleanup​

Delete all media and chat from the groups which have the following words in their name:
- Family 
- GEIT

Alternative:

Delete all media and chat from the archived groups

E-commerce Automation​

Smart Amazon Purchase Automation​

Automate Amazon purchase with intelligent decision making:
- Search for "e-gift card" and filter by denomination options
- Select Rs 3500 gift card with highest ratings and verified seller
- Add to cart and immediately proceed to "Buy Now" to bypass cart conflicts
- Navigate to checkout and verify delivery/billing addresses
- Select SBI card as payment method with secure handling
- Fill payment details but PAUSE at OTP verification step
- Implement screenshot capture and notification system for OTP prompt
- Include error handling for out-of-stock, price changes, or payment failures
- Log all steps with timestamps for audit trail

Safety measures: Include price verification, seller validation, and purchase confirmation before payment.

Playwright TypeScript Framework Creation​

Use this prompt to generate a complete, production-ready test automation framework using Playwright with TypeScript.

Prompt:

Create a modern, scalable, and modular test automation framework using Playwright with TypeScript that supports cross-browser testing (Chromium, Firefox, WebKit)

✅ Core Framework Requirements:
• Use Playwright's built-in test runner with TypeScript
• Follow Page Object Model (POM) design pattern with fixtures for dependency injection
• Use npm/yarn for package management
• Implement comprehensive logging and reporting (Playwright HTML Reporter, Allure, and custom reporters)
• Parallel test execution support with worker-based parallelization
• Custom fixtures for browser setup, page initialization, and test data management
• Base test fixtures that initialize browser context and pages based on configuration
• Add CI/CD pipeline using GitHub Actions with artifact publishing for reports
• README with comprehensive documentation and sample test usage
• Test data externalization using JSON/YAML files and environment-based configuration
• Docker support for containerized test execution
• Integration with Selenium grid and cloud testing platforms (BrowserStack, lambdatest)
• Do not miss important files like gitignore
• Use google.com as the sample application under test

✅ Fixture Requirements:
• Browser fixture for cross-browser testing setup
• Page fixture extending browser fixture for page-specific operations
• Test data fixture for loading external test data
• API fixture for API testing capabilities
• Custom fixtures for common test utilities (screenshots, video recording, etc.)

✅ Test Scenarios to implement:
• A test to validate no broken links exist on the page (should pass)
• A test to verify the number of images on screen exceeds a threshold (should pass)
• Search functionality tests (3-4 scenarios):
  - Valid search with results verification (should pass)
  - Search with special characters handling (should pass)
  - Search with extremely long query (should fail intentionally)
  - Search result pagination test (should fail intentionally for demo)

✅ Advanced Features:
• Visual regression testing capabilities using Playwright's screenshot comparison
• API testing integration for end-to-end workflows
• Mobile/responsive testing support with device emulation
• Accessibility testing integration
• Performance testing hooks (Core Web Vitals)
• Multi-environment configuration (dev, staging, prod)
• Custom retry mechanisms and flaky test handling
• Integration with test management tools
• Dockerized execution environment
• Cross-platform compatibility (Windows, macOS, Linux)

✅ Reporting & CI/CD:
• Generate and publish HTML reports, Allure reports, and JUnit XML
• GitHub Actions workflow with matrix strategy for cross-browser testing
• Artifact storage for test results, screenshots, and videos
• Slack/Teams notifications for test results
• Report hosting with GitHub Pages or similar
• Test trend analysis and metrics collection

This framework should demonstrate modern testing practices with Playwright's powerful features like auto-waiting, network interception, and built-in assertions while maintaining enterprise-grade scalability and maintainability.

Framework Enhancement Prompts​

API Testing Integration​

Extend the existing Selenium framework to include REST API testing capabilities using RestAssured. Include:
• API base classes and utilities
• JSON schema validation
• Response time assertions
• Data-driven API tests
• Integration with existing reporting

Mobile Testing Addition​

Add mobile testing capabilities to the existing framework using Appium. Include:
• Mobile driver management for iOS and Android
• Mobile page objects
• Device configuration management
• Cross-platform test execution
• Cloud device integration (Lambdatest / BrowserStack)

REST API Automation Framework Creation​

Use this prompt to generate a complete, production-ready API automation framework using REST Assured and Java.

Prompt:

Create a modern, scalable, and modular API automation framework in Java (Java 17 or 21) using Rest Assured and JUnit as the test runner.

The framework should include the following features:

✅ Supported HTTP Methods
Implement API request support for GET, POST, PUT, DELETE, and PATCH methods.

✅ Authentication Support
Support multiple authentication types:
• Bearer token
• API key
• Basic auth
• Support for setting headers dynamically from properties files or environment.

✅ Serialization / Deserialization
Use POJOs and Jackson/Gson libraries for request payload creation and response parsing.

✅ Framework Structure
Modular folder structure with separation of concerns:
• config, utils, testdata, models, tests, reporting, etc.
• Environment configuration management via .properties or .yaml files.
• Test data management via JSON.

✅ Execution & CI/CD
• Compatible with GitHub Actions and Azure DevOps Pipelines.
• Configurable test execution using Maven profiles or environment tags.

✅ Reporting
• Integrate Extent Reports or Allure Reports for detailed HTML reports.
• Include request/response logs, steps (for failure scenarios).

✅ Logging & Debugging
• Integrate log4j2 or SLF4J for detailed logs.
• Add logs for request/response, headers, and exceptions.
• Enable easy debugging and verbose logs when needed.

✅ Error Handling & Retry Logic
• Add a robust exception handling mechanism.
• Implement retry logic for flaky requests using a custom annotation or Rest Assured filters.

✅ Parallel Execution
Enable parallel execution of tests using JUnit parallel configuration or Maven Surefire plugin.

✅ Docker Support
• Provide a Dockerfile to run the test framework in containers.
• Use a docker-compose.yml file (optional) for service dependencies like mock servers or test APIs.

✅ Test Suites & Tagging
• Organize tests into suites (e.g., smoke, regression, auth tests).
• Use tags/annotations for running specific groups.

✅ Documentation
Provide a README.md with:
• Prerequisites
• Project structure explanation
• How to add a new test case
• How to run tests locally, in Docker, or via pipeline
• Sample command-line usages (e.g., mvn clean test -Denv=qa)

✅ Bonus (Optional Enhancements)
• Integrate with Postman or Swagger to import existing APIs if needed.
• Include utility to generate curl or HAR from failed tests for debugging.
• Add sample validations like status code, headers, response body match.
• Use JSONPath or similar libraries for complex JSON response validation.
• Add data-driven testing capabilities with CSV/Excel support.

Enjoyed this video?

Watch on YouTube•Subscribe for More•Like and Comment if this helped you!

Test Case Generation Prompts​

Comprehensive Test Scenarios​

Generate comprehensive test scenarios for [APPLICATION_TYPE] covering:
• Functional testing scenarios
• Edge cases and boundary conditions
• Negative test cases
• Performance considerations
• Accessibility requirements
• Cross-browser compatibility checks

Data-Driven Test Creation​

Create data-driven test cases for [FEATURE_NAME] that include:
• Multiple test data sets in Excel/CSV format
• Parameterized test methods
• Test data validation
• Expected vs actual result comparison
• Detailed test reporting with data sets

Code Review & Quality Prompts​

Code Quality Analysis​

Review this test automation code for:
• Best practices adherence
• Code maintainability
• Performance optimization opportunities
• Security considerations
• Documentation quality
• Potential flaky test patterns

Test Maintenance​

Analyze these test cases for maintenance improvements:
• Identify duplicate code patterns
• Suggest refactoring opportunities
• Recommend better locator strategies
• Propose wait strategy improvements
• Suggest reporting enhancements

Debugging & Troubleshooting Prompts​

Test Failure Analysis​

Analyze this test failure and provide:
• Root cause analysis
• Potential fixes
• Prevention strategies
• Improved error handling
• Better assertion messages
• Debugging recommendations

Performance Optimization​

Optimize this test automation code for:
• Faster test execution
• Reduced flakiness
• Better resource utilization
• Improved parallel execution
• Memory optimization
• Network call efficiency

Documentation Prompts​

README Generation​

Create a comprehensive README for this test automation project including:
• Project overview and architecture
• Setup and installation instructions
• Configuration guide
• Test execution commands
• Reporting and results interpretation
• Troubleshooting guide
• Contributing guidelines

Test Plan Documentation​

Generate a detailed test plan document for [PROJECT_NAME] including:
• Test strategy and approach
• Scope and objectives
• Test environment requirements
• Risk assessment
• Timeline and deliverables
• Success criteria

Usage Tips​

Customizing Prompts​

  1. Replace placeholders like [APPLICATION_TYPE] with specific details
  2. Add context about your current tech stack and requirements
  3. Specify constraints like timeline, team size, or technology limitations
  4. Include examples of existing code or patterns you prefer

Iterative Refinement​

  1. Start with basic prompts and gradually add complexity
  2. Provide feedback to the AI about what works and what doesn't
  3. Ask for alternatives when the first solution doesn't fit your needs
  4. Request explanations for generated code to improve understanding

Best Practices​

  • Always review and test generated code before implementation
  • Adapt prompts to match your organization's coding standards
  • Keep prompts updated with latest testing trends and technologies
  • Share successful prompts with your team for consistency

Website Quality Analysis Prompts​

Comprehensive Website Testing with AI​

Use this expert-level prompt to perform thorough website analysis with zero false positives. This prompt enforces strict verification rules and provides detailed, actionable reports.

Prompt:

You are an expert software tester and QA analyst (14+ years). Your job is to analyze this webpage: [INSERT URL] and report only confirmed issues — no false positives.

Spelling & Grammar:
• Rule-based spellcheck (dictionary lookup) on the exact visible text.
• Contextual grammar check using your language model.
→ Confirm if both flag the same text as wrong OR if the grammar check flags an actual meaning change. Provide text diff, correction suggestion, and element XPath.

Accessibility (A11y):
• Run an automated scan (axe-core or Lighthouse accessibility).
• Perform a keyboard navigation check (simulate Tab/Shift+Tab) or verify missing ARIA/alt attributes in DOM.
→ Confirm if (1) any rule fails AND (2) the element is missing attributes or keyboard focus fails. Attach rule id and axe/Lighthouse snippet.

UI (Visual Design) / Layout:
• Compute element bounding boxes (getBoundingClientRect) and check overlap/intersection ratio.
• Snapshot visual viewport; compare where overlap/overflow occurs across two viewport widths (desktop & mobile).
→ Confirm if bounding box intersection > 15% (or text cut-off) on at least two viewports/reloads. Attach screenshots and bounding-box coords + XPath.

UX / Usability:
• Perform the key user flow(s) (e.g., signup → confirm).
• Check microcopy, CTA clarity, or error messages for ambiguity (language model check).
→ Confirm if user cannot complete flow or error messages lack actionable guidance across 2 attempts. Provide steps, expected vs actual, and screenshots.

Functional:
• Execute the UI action. Observe the network/XHR response and console logs.
• Validate the actual behavior (navigation/state) against expected outcome.
→ Confirm if the network response is error (HTTP >=400) and/or console error occurs AND the UI behavior is incorrect on 2 attempts. Provide endpoint, status, request/response snippet, console stack trace, XPath.

Performance:
• Run a Lighthouse/performance audit or measure TTFB, FCP, LCP, TBT.
• Check network waterfall for long blocking resources or repeatedly slow XHR calls.
→ Confirm if thresholds exceeded on 2 runs (default thresholds: LCP>2.5s, TBT>300ms, TTI>5s) or same XHR >2s on 2 attempts. Attach timings and waterfall snippet.

Security:
• Inspect for mixed content / insecure HTTP calls in Network tab.
• Inspect response headers set for cookies (HttpOnly, Secure, SameSite) and any tokens in JS strings.
→ Confirm if insecure calls exist on 2 reloads or if cookies lack Secure/HttpOnly where expected. Provide network entries and header snippets.

API / Background Calls:
• Filter XHR/fetch and repeat the user action to re-trigger calls twice.
• Confirm failing responses repeat with same HTTP error or payload.
→ Confirm if two consecutive attempts return error or malformed payload. Include request payload, response body, endpoint, status and timestamp.

SEO / Metadata:
• View page source for meta tags (title, description, canonical).
• Run Lighthouse SEO audit.
→ Confirm if meta is missing or mismatched in source and Lighthouse flags it.

Cross-Browser / Mobile:
• Simulate user agent / rendering differences (if browser environment supports); reload and verify.
• If multi-browser simulation isn't available, mark as Unverified and list exact manual steps to run (or request a BrowserStack session).

Usage Example:

Replace [INSERT URL] with the actual website URL you want to test:

You are an expert software tester and QA analyst (14+ years). Your job is to analyze this webpage: https://www.example.com and report only confirmed issues — no false positives.
[... rest of the prompt ...]

What This Prompt Tests:

  • ✅ Spelling and grammar errors with dictionary and contextual validation
  • ✅ Accessibility issues (WCAG compliance, keyboard navigation, ARIA)
  • ✅ Visual design and layout problems (overlaps, responsive issues)
  • ✅ User experience and usability concerns
  • ✅ Functional bugs with network validation
  • ✅ Performance bottlenecks (Core Web Vitals)
  • ✅ Security vulnerabilities (mixed content, headers)
  • ✅ API and background call failures
  • ✅ SEO and metadata issues

Practice Automation Website Builder​

Comprehensive Automation Training Platform​

Use this prompt to create a complete practice automation website that covers all real-world testing scenarios. Perfect for training on Selenium, Playwright, Cypress, or any automation framework.

Prompt:

Create a comprehensive practice automation website designed for testers and developers to train on test automation frameworks (Selenium, Playwright, Cypress, etc.). The site should include all possible elements, flows, and scenarios commonly faced in real-world projects.

✅ Basic Elements Section

Textboxes:
• Single-line text input
• Multi-line textarea
• Input with character limits
• Input with format validation (email, phone, numbers only)

Password Fields:
• Standard password field
• Password with show/hide toggle
• Password with strength indicator
• Confirm password field with validation

Dropdowns:
• Single select dropdown
• Multi-select dropdown
• Searchable/filterable select
• Cascading/dependent dropdowns
• Dropdown with dynamic options

Radio Buttons & Checkboxes:
• Standard radio button groups
• Checkbox lists (select all/none)
• Disabled and pre-selected options
• Dynamically enabled/disabled options

Buttons:
• Enabled/disabled buttons
• Dynamic enable/disable based on form validation
• Loading/spinner state buttons
• Submit/reset/cancel variations
• Icon buttons and button groups

Links:
• Internal navigation links
• External links (open in new tab)
• Dynamic links (generated on interaction)
• Broken link examples for testing

✅ Intermediate UI Scenarios

Drag & Drop:
• Drag elements between containers
• Sortable lists with drag-and-drop
• File drag-and-drop upload
• Drag to reorder table rows

Sliders:
• Single value range slider
• Dual-value range slider
• Vertical and horizontal sliders
• Step-based sliders with value display

File Operations:
• Single file upload
• Multiple file upload
• File type restrictions
• File download with various formats (PDF, CSV, Excel)
• Download with dynamic filenames

Date Pickers:
• Standard calendar picker
• Date range picker
• Custom date format selectors
• Min/max date restrictions
• Disabled date ranges

Mouse Interactions:
• Mouse hover effects and tooltips
• Right-click context menus
• Double-click actions
• Click and hold interactions

Copy/Paste:
• Copy-to-clipboard buttons
• Paste detection and validation
• Protected/disabled copy fields

Auto-Suggestions:
• Search with live suggestions
• Debounced auto-complete
• Keyboard navigation in suggestions
• Selection and clearing behavior

✅ Advanced Features

Iframes:
• Single iframe
• Nested iframes (iframe within iframe)
• Multiple iframes on same page
• Cross-origin iframe scenarios

Shadow DOM:
• Elements within shadow DOM
• Nested shadow DOM elements
• Form elements in shadow DOM

Multiple Windows/Tabs:
• Open new window/tab button
• Handle multiple browser tabs
• Switch between windows
• Close specific windows

Pop-ups & Modals:
• JavaScript alerts
• Confirm dialogs
• Prompt dialogs
• Custom modal dialogs
• Overlay modals with backdrop
• Non-closable modals (require action)

Infinite Scroll / Lazy Loading:
• Infinite scroll list
• Load more button
• Virtual scrolling with large datasets
• Lazy-loaded images

Dynamic Elements:
• Elements with dynamic IDs
• Dynamically generated content
• Elements appearing after delay
• Elements changing position/state

Notifications:
• Toast notifications (success, error, warning, info)
• Auto-dismiss notifications
• Dismissible notifications
• Notification queues

Data Visualizations:
• Bar charts
• Line graphs
• Pie charts
• Interactive charts with tooltips
• Canvas-based drawing board

✅ System/Browser Features

Geo-location:
• Mock geo-location permission
• Location-based content display
• Map integration examples

Browser Notifications:
• Push notification permission request
• Trigger browser notifications
• Handle notification clicks

Storage Management:
• Set and read cookies
• Local storage operations
• Session storage operations
• Clear storage buttons

Internationalization:
• Multi-language support
• Runtime language switcher
• RTL (Right-to-Left) language support
• Date/number format changes

✅ End-to-End Business Flows

User Authentication:
• Login with valid/invalid credentials
• Registration form with comprehensive validations
• Password reset flow
• CAPTCHA integration (optional/mock)
• Session management
• Logout functionality

E-commerce Flow:
• Product listing page with filters
• Product detail page
• Add to cart functionality
• Cart management (update quantity, remove items)
• Checkout process (address, shipping, payment)
• Order confirmation page
• Payment simulation (success/failure scenarios)

Search & Filtering:
• Search with results
• Filter by multiple criteria
• Sort options (price, name, date)
• Pagination (numeric, prev/next, load more)
• No results handling

Profile Management:
• View profile
• Edit profile with validations
• Upload profile picture
• Change password
• Account settings

Contact Form:
• Multi-field contact form
• Form validation (required fields, format)
• Submission with success/error states
• Email mock/confirmation message

✅ Complex/Dynamic Scenarios

Asynchronous Loading:
• Elements loading with delays (1s, 3s, 5s)
• Retry mechanisms for failed loads
• Timeout scenarios
• Skeleton loading states

Hidden & Overlapping Elements:
• Hidden elements (display: none)
• Invisible elements (opacity: 0)
• Elements behind overlays
• Partially visible/scrollable elements

Tables:
• Static data tables
• Dynamic/editable tables
• Sortable columns
• Filterable tables
• Row selection (single/multiple)
• Expandable rows
• Pagination in tables

API-Driven Content:
• Content loaded from mock APIs
• Loading states during API calls
• Error handling for failed API calls
• Retry logic for API failures

Real-Time Updates:
• WebSocket live updates
• Polling-based updates
• Live counters/timers
• Real-time form validation

Network Conditions:
• Slow network simulation
• Offline mode handling
• Network error scenarios

✅ Documentation & Setup

Include comprehensive README with:
• Purpose and use cases for each section
• Recommended automation approaches
• Common pitfalls and solutions
• Framework-specific examples (Selenium, Playwright, Cypress)
• Mobile responsive design
• Accessibility considerations
• Source code with clear comments

Technical Requirements:
• Modern HTML5, CSS3, JavaScript
• Responsive design (mobile, tablet, desktop)
• No authentication barriers (open access)
• Clean, semantic HTML
• Unique element identifiers (IDs, data-testid attributes)
• Console-friendly for debugging
• Hosted version or easy local setup

🎯 Goal: Create a one-stop playground where automation engineers can practice all major and minor test automation scenarios encountered in real-world projects, from basic element interactions to complex business flows and edge cases.

Key Benefits:

  • ✅ Comprehensive coverage of all automation scenarios
  • ✅ Real-world business flow simulations
  • ✅ Framework-agnostic (works with any automation tool)
  • ✅ Progressive difficulty levels (basic to advanced)
  • ✅ Includes edge cases and complex scenarios
  • ✅ Perfect for training and interview preparation
  • ✅ Covers modern web technologies (Shadow DOM, WebSockets, etc.)

Contributing to the Library​

Found a useful prompt or want to suggest improvements?

Connect with me:

This prompt library is continuously updated with new testing and automation scenarios. Bookmark this page for regular updates and new prompt additions.