my thoughts: there's a lot of functionality here, which is great, but this is very overbuilt. a lot of this will not be so easy to maintain in the long run. I also really don't like having assertions and other basic Playwright functionality buried in functions, especially when the functions are mostly just single Playwright actions; why wrap them at all? when I look at one of these tests, I have to click thru a bunch of functions to see what's actually happening. like this test has a dozen assertions in it but I don't know exactly what's being asserted without looking at every function. import test from '@lib/BaseTest'; test(`@Smoke Verify Elements Page`, async ({ loginPage, elementsPage, webActions }) => { await loginPage.navigateToURL(); await webActions.clickByText('Elements'); // Click on Elements Icon identified via text selector await webActions.clickByText('Text Box'); //Click on TextBox Navigation Sidebar identified via text selector await elementsPage.enterFullName(`AutoTest`); await elementsPage.clickSubmit(); await elementsPage.verifySubmittedText(); await webActions.clickByText('Check Box'); await elementsPage.clickHomeCheckBox(); await elementsPage.verifyHomeCheckboxSelectedText(); await webActions.clickByText('Radio Button'); await elementsPage.verifyNoRadioButtonDisabled(); await webActions.clickByText('Web Tables'); await elementsPage.verifyFirstColumnTableHeader('First Name'); await elementsPage.editCierraEntry(); await elementsPage.verifyRegistrationForm(); await elementsPage.registrationFormClose(); await webActions.clickByText('Buttons'); await elementsPage.doubleClickButton(); await elementsPage.verifyDoubleClickText(); await elementsPage.rightClickButton(); await elementsPage.verifyRightClickText(); await webActions.clickByText('Upload and Download'); await elementsPage.verifyFileDownload(); await elementsPage.verifyFileUpload(); await webActions.clickByText('Links'); await elementsPage.verifyNewBrowserTab("https://demoqa.com/"); }); there's a mix of page object actions and webActions actions here that I don't understand. why is web actions handling some of the clicking and page object functions handling other clicking? looking at ElementsPage.ts, almost all of these functions are single lines. why have them in functions? all of these single lines could be in the test directly, making the test a lot more clear as to what's actually happening and greatly reducing the amount of code. async enterFullName(name: string): Promise { await this.FULL_NAME_EDITBOX.fill(name); } async clickSubmit(): Promise { await this.SUBMIT_BUTTON.click(); } async verifySubmittedText(): Promise { await expect(this.SUBMITTED_TEXT).toBeVisible(); // Verifies if the text is visble on webpage } async clickHomeCheckBox(): Promise { await this.HOME_CHECK_BOX.check(); } async verifyHomeCheckboxSelectedText(): Promise { await expect(this.HOME_SELECTED_TEXT).toContainText('home'); // Verifies if the locator contains text } async verifyNoRadioButtonDisabled(): Promise { expect(this.NO_RADIO_BUTTON).toBeDisabled() } async verifyFirstColumnTableHeader(header: String): Promise { const headerText = await this.WEB_TABLES_HEADER.allTextContents(); // Get all Text from WebTable Header expect(headerText[0] == header).toBeTruthy(); // Verify the First Column Header here we are comparing string values } async editCierraEntry(): Promise { await this.WEB_TABLES_EDIT_ICON.click(); } async verifyRegistrationForm(): Promise { await expect(this.REGISTRATION_FORM_HEADER).toBeVisible(); } async registrationFormClose(): Promise { await this.REGISTRATION_FORM_CLOSE_BUTTON.click(); } async doubleClickButton(): Promise { await this.DOUBLE_CLICK_BUTTON.dblclick(); } More on reddit.com

I wouldn't actually use a lot of those snippets. There are better ways. Like with the browser, just use the Page Fixture and don't create your own context. Also this doesn't tell you where to put these commands. It's just a big list. Some of this is code and some if it is console commands and there's no real distinction. More on reddit.com

Well even though ideally you run all tests against all PRs eventually you may have too many tests. Just a couple of ideas: run more workers/threads try to mock where you can maybe try component testing pick a subset (smoke) test set run that create a map of code files to tests. Determine what tests to run based on files being changed I would probably pick a small set of must pass test. Put this in front of prs. Run the rest of the test maybe twice or once a day Not sure any of these ideas will help but ya…. More on reddit.com

imo do all assertions in your spec file (no assertions in a page object) do all page interactions in a page object file (no locators in a spec file) use playwright's expect assertions over generic assertions (toBe, etc). playwright's internal error handing is awesome fixtures are useful I do something similar to this setup, where I have page object classes and page component classes. for example, I have a table page component that contains locators and functions for interacting with tables on various pages across our site. this way I don't have to rewrite the same table code in every page object- https://github.com/microsoft/playwright/issues/1604#issuecomment-1004711489 don't be afraid to parametrize tests or dynamically generate tests for repetitive testing. if you need to assert the same thing on a bunch of different pages, put them in an object and loop through it instead of writing the same test over and over, etc. https://playwright.dev/docs/best-practices More on reddit.com