A Test Automation Portfolio Beats Another Playwright Course

QA engineer pointing at a single failing red tile in a grid of passing green runs, the kind of triage history a test automation portfolio records
In this post
  1. So why does the course not transfer?
  2. What is an interviewer actually screening for?
  3. What goes into a test automation portfolio
  4. Pick an application you do not control
  5. The two-week version if you already have a job
  6. How to say it on a CV without overclaiming
  7. Where Nopmark fits
  8. FAQ

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.

So why does the course not transfer?

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.

What is an interviewer actually screening for?

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.

What goes into a test automation portfolio

You need one repository, not five, and not a folder of exercise solutions with the course's name still sitting in the README.

  • A suite that runs against an application you do not own. This is the whole point, so it earns the most space here. A public site you have no control over will break your tests for reasons unrelated to your code, which is exactly the condition you are trying to prove you can handle. Pick something with a real login, a form with validation, and a list view you can filter.
  • Continuous integration that actually runs. GitHub Actions is enough. Nobody cares about the badge. What they read is the run history, because that is a dated record of your suite passing and failing over months.
  • A flake log. Keep a markdown file recording every failure that turned out not to be a product bug, what caused it, and what you changed in response. Most candidates hide flakiness from their repositories. Documenting it tells an interviewer you have done triage.
  • A README that states what you left out. Two paragraphs on what you decided not to automate, and why you decided it.

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.

Pick an application you do not control

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.

The two-week version if you already have a job

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.

How to say it on a CV without overclaiming

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.

Where Nopmark fits

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

FAQ

How many tests should a test automation portfolio contain?

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.

Should I use Playwright, Cypress, or Selenium?

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.

Does an open-source contribution work instead?

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.

Will a portfolio get me past an automated CV screen?

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.

I am not a strong programmer. Is this still realistic?

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.

Keep reading