Risk-based testing: check your scores against escaped defects
Take a QA lead whose team uses risk-based testing to plan each sprint. Every story gets a risk score, the team tests the high scorers first, and the low scorers…
You have read this

A Playwright course will teach you the framework in a few weekends. Somebody with 5 years of manual testing behind them posted this week that they had done exactly that, worked through the hands-on practice as well, and still could not bring themselves to write automation engineer on a CV. Most of the answers underneath told them to go and take another course. That advice is wasteful. What closes the gap is a test automation portfolio: one repository that shows you keeping a suite alive against software you do not control.
Because it taught you against a target that was built to cooperate, and cooperation is the one thing production software will never offer you.
Consider what the demo application in a course does not do. It does not change under you between Tuesday and Thursday. It does not sit behind a third-party login that starts rate-limiting you at 09:00 on a Monday. It does not deploy on a Friday afternoon and quietly rename the data attribute your locator depended on. It does not reset its seed data at midnight so that three of your assertions are now written against yesterday's records.
Real software does all of that, and absorbing it is most of the work. So the syntax was never the hard part, and the course gave you the syntax.
Not whether you can produce working test code. They assume that now, and so should you, because the frontier models produce working test code on request and everybody in the room knows it.
So what is left to ask you about? Can you tell a real failure from a noisy one? Can you decide what does not deserve a test at all? Those are the two questions a course app never put in front of you, because a course app only ever fails when you write the test wrong. Software written by other people fails for reasons that have nothing to do with you, and learning to sort those two cases apart is the skill that gets paid.
There is a related habit courses teach by accident. They show you a test case, then show you how to automate it, which quietly trains the manual-then-automate sequence. In practice you should write the automated script directly from the acceptance criteria. The manual-first route seems logical and it seems easy, but the rerun pressure never lets up, you never find the time to go back and automate anything, and teams that work that way tend to solve it by doubling their headcount instead. If your repository shows you going straight from a requirement to a running check, you are already doing something most candidates cannot describe.
You need one repository, not five, and not a folder of exercise solutions with the course's name still sitting in the README.
Anyone can add tests. Explaining what you deliberately left out, and then defending that reasoning under questioning, is how you show you can interrogate a system rather than simply exercise it.
The instinct is to build a small app and test that. Resist it. Testing something you wrote yourself proves only that you can write assertions against your own assumptions, and your assumptions are usually where the bugs live.
Good targets are public, stable enough to be useful, and unstable enough to be interesting. A documentation site with search. An open-source web application you can run locally from a published Docker image, so that pulling a newer tag hands you real version changes to react to. A public API with a rate limit, so you have to think about retries and about which failures deserve one.
Then give it 6 weeks of calendar time rather than a weekend. A weekend gets you a snapshot of something working. Six weeks gets you a history of something surviving, and the history is what makes the repository evidence at all. It is also what lets you answer "tell me about a test that kept failing" with a commit instead of a hypothetical.
Not everyone has 6 weeks of evenings available. If you are employed and want something defensible sooner, tailor the scope down and keep the rigor where it is.
Take one workflow you already test by hand at work and rebuild it as an automated check against a public equivalent. If you test an insurance quote form, go and find a public quote form. Keep the flake log from the first day. You will finish with something like 12 tests rather than 40, and 12 tests carrying a documented failure history will do more for you than 40 that have only ever run on your laptop.
Do not write automation engineer if the last 5 years of your title said manual QA. You will be caught inside the first 10 minutes and it will cost you the room.
Write something true and specific instead. Built and maintained a Playwright suite in CI against a third-party application over 6 weeks, with 12 end-to-end checks and a documented triage log covering 9 intermittent failures. That sentence survives scrutiny. It also invites precisely the follow-up question you have spent 6 weeks preparing to answer.
Nopmark's programs cover the reasoning half of this work: test analysis, test design, and how you decide what deserves a check before you write one. A course application cannot simulate that, and it does not go obsolete when the tooling changes underneath you.
So the repository and the certification are doing two different jobs for you. One demonstrates that you can keep something running against a moving target. The other demonstrates that you share the vocabulary and the process discipline your future colleagues are already working from. Bring both and the interview stops being about whether you can write a locator.
Ready to build the reasoning half? See Nopmark's certification programs: https://www.nopmark.com
Somewhere between 10 and 20 end-to-end checks is plenty. Reviewers do not count tests. They open two or three, look at how you structured your locators and assertions, and read the README. A small suite you can explain in depth beats a large one you cannot.
Use Playwright unless a specific job you want names something else. It has the strongest parallelization story, and the frontier models extend it natively, which matters a great deal when you are working alone with nobody to review your code.
It does, and it is arguably stronger, because the review history is public and somebody else signed off on your work. It is also slower and depends on a maintainer answering you. Build the repository first and contribute when the opportunity appears.
On its own, no. The screen matches keywords, so the specific sentence on your CV is what does that job. The repository is what turns a first conversation into a second one.
Yes. Test automation asks for a narrow slice of programming applied carefully, and the harder skill has always been deciding what to check. If you can read a stack trace and reason about why a selector stopped matching, you have enough to start.
Take a QA lead whose team uses risk-based testing to plan each sprint. Every story gets a risk score, the team tests the high scorers first, and the low scorers…
You have read this