Learning Software Testing from Scratch: Four-Dimension Analysis and a 27-Stage Learning Roadmap

At the crossroads of choosing an IT career, many people face a practical question: frontend, backend, testing, or operations—which direction suits them best? In the opening of a "nanny-level" software testing course on Bilibili, one UP host laid out a framework for making that judgment, and systematically broke down the real landscape of software testing roles along with a complete learning path.

Choosing an IT Direction: Start with These Four Dimensions

Faced with so many computer science specializations, the UP host recommends evaluating them across four dimensions: salary, job demand, skill requirements, and future prospects. The value of this approach is that it converts the subjective feeling of "what do I like" into verifiable objective indicators, making it especially useful for career changers starting from zero to reduce the cost of trial and error.

Salary is the metric most people care about first. According to BOSS Zhipin statistics shown by the UP host, software testing salaries in Beijing have risen steadily since 2019, peaked around 2023, then entered a plateau during 2024 to 2026, currently holding at around 17.5K. The data is current as of February 26, 2026, with a large sample size that offers reasonable reference value.

Job demand needs to be verified on actual recruitment platforms. The UP host demonstrated with BOSS Zhipin and Lagou—searching for software testing roles in Beijing on Lagou shows about 500 companies with positions, spanning 30 pages of results, and the last page still has testing jobs open, indicating that market demand has not shrunk. Compared with BOSS Zhipin's endless scroll-to-load approach, Lagou's paginated display makes the scale of demand more intuitive. This "let data speak" method is far more reliable than simply listening to others debate whether testing has a future.

Education Threshold and Salary Ceiling

Based on job postings, software testing roles are fairly inclusive when it comes to education. On BOSS Zhipin, the UP host observed openings for vocational school, associate degree, and bachelor's degree candidates, with higher education levels corresponding to better pay. Associate degree positions are plentiful, while a bachelor's degree can reach higher salary ranges.

This means education isn't a hard threshold, but it does affect the salary ceiling. The UP host also specifically distinguished a category of "daily-wage" temporary positions—these have low education requirements and low pay, and are a special case that needs to be identified.

In terms of skill requirements, testing roles aren't particularly demanding about background; in terms of future prospects, as long as applications exist, testing demand won't disappear. It's unlikely to see explosive growth, but it's also unlikely to suddenly vanish.

On recruitment platforms, the common "daily-wage" positions usually belong to outsourcing or short-term project-based employment, with pay settled by the day and without full social insurance, housing fund, or year-end bonuses. These roles have a low entry barrier, but poor career stability and limited technical accumulation—staying in them long-term can trap you in a cycle of "repetitive work—stagnant salary." For career changers, the way to identify such positions is to look at the salary unit in the job posting (e.g., "200/day" rather than "8-12K/month"), the contract entity (third-party staffing companies), and whether the job description emphasizes "short-term" or "on-site project work." When planning your career path, prioritize formally employed testing positions and treat outsourcing experience as a transition rather than an endpoint.

27 Stages: From Functional Testing to AI Automation

The course outline is divided into 27 stages, covering a complete path from beginner to advanced. The first few stages focus on foundational skills: software testing fundamentals, functional testing and project practice, followed by Windows and Linux operating system knowledge, Web frontend basics, MySQL databases, Docker containerization, and problem diagnosis and log analysis.

Python is the primary language of this course, starting at stage ten and going deeper in stage eleven. After that comes the core of automation testing: client automation, Web automation, test framework design and best practices, and API automation (which the UP host calls "the top priority"), each paired with hands-on projects.

The latter half of the course covers APP testing and practice, Git version control, AI automation testing, continuous integration, security testing, performance testing and practice, and finishes with interview question walkthroughs and interview techniques. The logic behind this outline is: first build testing thinking, then supplement development and operations fundamentals, and finally arm yourself with an automation toolchain—matching companies' hiring trend toward test engineers who "know code and can automate."

API automation refers to writing automated scripts against the APIs (Application Programming Interfaces) a system exposes, bypassing the graphical interface to directly verify data flow and business logic. Compared with Web or APP automation, API automation runs faster, is more stable, and can begin testing before the product UI is even finished, so it's often seen as the highest-ROI direction in automation testing. It typically relies on Python's requests library to send HTTP requests, uses pytest to manage test cases and assert on responses, and integrates tools like Allure to generate visual reports. For companies, API automation is a core part of the continuous integration pipeline, and a key interview topic that distinguishes ordinary testers from automation test engineers.

Continuous Integration (CI) is a development practice: team members frequently merge code into the main repository, and each merge triggers automated build, test, and deployment processes, catching integration errors as early as possible. In testing roles, CI matters because it plugs automated test scripts into pipelines like Jenkins or GitLab CI, so regression tests run automatically after code commits rather than waiting for a manual scheduled execution. Test engineers need to understand pipeline configuration, test report collection, and failure-blocking mechanisms—which is exactly why the course places continuous integration in the latter half: it requires mastering automation scripts first before talking about engineering implementation.

Who This Roadmap Is For

The course is positioned as "nanny-level starting from scratch," with accompanying videos, source code, and documentation. For career changers with no programming background at all, 27 stages is a substantial amount of learning, but the path is clear. Keep in mind that stages like AI automation testing and continuous integration reflect new industry requirements for testing roles—test engineers are no longer just clicking around, but need to understand CI/CD workflows and AI-assisted testing tools.

If you're still hesitating about entering software testing, why not first verify things yourself using the UP host's method: open a recruitment platform, search for your target city and target salary, and see whether the number of positions and education requirements match your expectations. Data is more persuasive than opinions.

One-line Summary

A four-dimensional assessment of software testing—salary, demand, skills, and prospects—plus a breakdown of a 27-stage learning path.

Paragraph Summary

Based on the opening of a Bilibili UP host's software testing course, the article first proposes a four-dimensional evaluation framework for choosing an IT direction: salary, job demand, skill requirements, and future prospects. Citing data from BOSS Zhipin and Lagou, the author notes that software testing salaries in Beijing plateaued during 2024 to 2026 at around 17.5K, and that job demand has not shrunk; the education threshold is relatively loose, with openings for vocational, associate, and bachelor's degree holders, but higher education brings a higher salary ceiling. The article then breaks down a 27-stage learning path: from software testing fundamentals and functional testing practice, to Python programming, Web frontend, MySQL, Docker, and log analysis, then client/Web/API automation and test frameworks, and finally APP testing, Git, AI automation, continuous integration, security and performance testing, and interview preparation. The article emphasizes that test engineers are shifting from "clicking around" to hybrid roles that know code and can automate.