QA & Software Testing for Beginners
by Sergey Okinchuk
Ch. 1

QA & Software Testing for Beginners

Welcome

Software testing is one of the most common ways people without a technical background break into tech — and one of the most misunderstood jobs in it. This course fixes both. It takes you from "what's a bug?" to the point where you could start a QA career: you'll design tests instead of guessing, write a bug report a developer acts on in one read, run the testing process from planning to the release decision, and hold a confident conversation on any testing topic — APIs, automation, performance, security, accessibility, mobile, AI. No coding, nothing to install. One running example — Fernway, a travel-booking app — carries every technique, and the final chapter turns the whole book into a job: portfolio, interview answers, and your first 90 days.

12 chapters 53 topics covered 7.5 hours audio Knowledge check on every topic

About This Course

Software testing carries a strange reputation: everyone agrees quality matters, and most explanations either drown you in certification jargon or reduce the whole craft to "clicking around and finding bugs." The real subject is neither — it's a genuine engineering discipline with its own techniques, vocabulary, and judgment, and it happens to be one of the most accessible entry points into a tech career for someone starting from zero. This course teaches that discipline, honestly and from the ground up, for a reader who has never written a line of code.

To keep everything concrete, the whole book follows one job. You are hired as the first dedicated QA engineer at Fernway, a travel-booking service, after a bad weekend where a discount bug refunded forty bookings. Chapter by chapter, you learn the craft and apply it to Fernway's screens, rules, and bugs — the same fixed cast (Nadia the lead, Omar and Lucy the developers, Petra the product manager) and the same running defects (the date-picker bug FW-312 follows you through half the book). By the end, "testing by hoping" has become testing on purpose, and the fiction has quietly become your portfolio template.

This is a concept-first course with no code and nothing to install. Where something code-like genuinely clarifies — an HTTP request, a database query, an automated test's shape — it's shown as a readable artifact and explained fully in plain words, so you can read the whole book on a phone on a train and lose nothing. The tools of the trade (Jira, Postman, Selenium, Playwright, k6, Appium) are taught as concepts and categories, never as tutorials — because tools churn and the thinking endures.

Who This Is For

Anyone heading toward a QA career from outside tech: career-switchers preparing for a first junior role and its interview, students who want the real discipline before the buzzwords, and support or business people who work next to software teams and want to understand — or join — the testing side. It assumes no engineering background at all: no coding, no command line, no prior knowledge of servers, APIs, or databases. Every technical concept the book needs is built up from zero. If you already test software professionally, this course is below you; if "QA" has always been a vague box on an org chart, it was built for exactly you.

What You Should Already Know

  • How to use a computer, a browser, and an app as an everyday user — nothing more technical than that
  • No programming and no command line — the course is deliberately code-free, and every technical idea is introduced from scratch
  • No prior testing knowledge — every term, from "regression" to "idempotent," is defined the first time it appears
  • Curiosity about how things break — the one trait that makes a good tester, and the only prerequisite that matters

How the Course Is Built

The twelve chapters build in a deliberate order. First the foundations — why software breaks, what QA really means, and the seven principles the whole field rests on — then the context of how software gets built, so testing has somewhere to live. The heart of the book is the manual craft: the map of testing (levels and types), test design (the techniques that turn guessing into engineering), documentation, bug reporting, and the testing process end to end. From there the world widens: testing web apps and APIs beneath the screens, automation explained without code, the specialist fields (performance, security, usability, mobile), and AI's place in modern testing. The final chapter turns all of it into a career: portfolio, interview, and first job.

Every topic has the same gentle shape: a hook from Fernway to start, the idea built one step at a time, one everyday comparison to make it stick, the mix-ups beginners usually run into, why it matters, and a short knowledge check. It is patient, but it keeps moving — you are here to learn a profession, not to be slowed down.

Concept-first, no code
Nothing to install and no programming required. Tools appear as concepts and categories; where a snippet clarifies, it's shown and explained in plain words beside itself.
One company, all the way through
Fernway's rules, team, and bugs accumulate across every chapter, so each new technique lands on a product — and a cast of defects — you already know by heart.
A career, not just a topic
Aligned with the ISTQB vocabulary interviews are built on, and ending in a real hiring plan: portfolio artifacts, the interview answer key, and the first 90 days.
Honest, never hyped
No folklore sold as fact — "manual testing is dying," "automation replaces testers," "you must know Selenium." Every claim is stated with its honest trade-offs.

Chapter Map

Chapter 1
What Testing Is
Why software breaks, the difference between testing, QC, and QA, the seven principles that are the field's laws of physics, an honest day in the life — and meeting Fernway.
Chapter 2
How Software Gets Built
The tester's context: the SDLC and why testing moved earlier, agile and the sprint rhythm, requirements and acceptance criteria, and the environments where testing happens.
Chapter 3
Test Levels & Test Types
The coordinate system: unit to acceptance, functional versus non-functional, the three shades of box, the change vocabulary, and finding bugs without running the code.
Chapter 4
Test Design
The heart of the craft: partitions, boundaries, decision tables, state transitions, and pairwise — the techniques that turn a field's infinite inputs into a few dozen aimed checks.
Chapter 5
Test Documentation
Writing the craft down: the one-page test plan, test cases built and broken, the three documentation weights, and test data with the traceability thread.
Chapter 6
Bugs: Finding, Reporting, Managing
What a bug is (and isn't), the report a developer acts on in one read, severity versus priority with the lifecycle, and the tracker where all of it lives.
Chapter 7
The Testing Process
One release week: risk-based planning, execution discipline, exploratory testing, and the Friday release decision — where QA informs but the team decides.
Chapter 8
Testing Web & APIs
Beneath the screens: the browser-to-database relay, DevTools as an X-ray, the API where rules live directly, one readable SQL query, and third-party integration seams.
Chapter 9
Test Automation Without the Code
The machines, explained code-free: the test pyramid, how automation finds a button and why tests go flaky, the tool landscape, CI/CD gates, and the career paths.
Chapter 10
Beyond Functional
The specialist fields at conversational depth: performance and the sale, security's attacker question, usability and accessibility, and mobile's hostile physical world.
Chapter 11
AI and the Future of Testing
The frontier on familiar ground: AI as a draft-then-audit assistant, testing AI features with evals and rates, and shift-right — flags, canaries, and testing in production.
Chapter 12
Your QA Career
Skill into a job: the portfolio the market hires on, the predictable junior interview's answer key, surviving the first 90 days, and the growth paths beyond.

Disclaimer

This course is an independent educational project created and maintained by Sergey Okinchuk. It is provided for learning and reference purposes only.

No affiliation. This course is not affiliated with, sponsored by, endorsed by, or officially connected to any company, product, or organization mentioned. All opinions, interpretations, and recommendations expressed are those of the author. Fernway and all characters in this course are fictional; any resemblance to real companies or persons is coincidental.

Trademarks. Product and company names referenced — including any testing tools, trackers, or frameworks — are the property of their respective owners. Use of these names is for identification and educational purposes only and does not imply any endorsement.

Educational simplifications. This material teaches durable concepts for understanding, not operational instructions. Explanations are deliberately simplified for learning; where a simplification could mislead, the text flags it. This course is not professional advice, and is not a substitute for qualified expertise in any decision involving software quality, security, or release.

Accuracy and currency. Software testing evolves — tools, frameworks, and practices drift over time, and the AI material in particular reflects a fast-moving field. Facts in this course reflect the author's understanding at the time of writing and may not be current. The course deliberately teaches durable fundamentals and standard (ISTQB-aligned) vocabulary rather than product specifics; always consult authoritative sources for the current state of any tool or standard.

No warranty. This material is provided "as is" without warranty of any kind. The author accepts no liability for any loss or damage arising from reliance on the content.