PCAP-31-04: the new Python exam active on November 3, 2026

As of November 3, 2026, PCAP-31-04 is the active Python Institute Certified Associate Python Programmer exam. This is more than a code change: the outline expands from five to six domains, the exam now contains 42 questions, and the syllabus adds structural pattern matching, pathlib, testing, debugging, collaborative development, and controlled use of AI assistance. The exam remains in English, lasts 65 minutes, and requires 72% to pass.

This matters immediately to candidates already preparing for PCAP-31-03. The Python foundation still transfers, but old domain weights and 40-question practice tests no longer represent the current exam precisely. The sensible response is to keep valid knowledge, then close the gaps against the official outline revised on November 2, 2026.

Confirmed PCAP-31-04 details

The official PCAP certification page (opens in a new tab) now displays PCAP-31-04 and offers a voucher purchase route. The official PCAP-31-04 syllabus (opens in a new tab) identifies the November 2, 2026 revision, blueprint 1.5, and six sections. These are the published conditions as of November 3:

Python Institute does not state one universal amount on the exam page. Candidates are directed to review current options and prices in the OpenEDG store. Publishing a single fee without a country, taxes, or offer would therefore be misleading. Check the final amount presented before payment.

Published question formats include single-select, multiple-select, interactive, code-based, and scenario-based items. A failed attempt triggers a 15-day waiting period. Existing PCAP credentials remain valid; launching PCAP-31-04 does not cancel a PCAP credential earned under an earlier exam version.

The new outline and weights

Object-oriented programming remains the largest block, although its relative share is lower. Strings move from 18% in PCAP-31-03 to 9.5%, while an entirely new domain covers quality, collaboration, and AI assistance. That lower string weight is not permission to ignore text handling: string behavior can still appear inside scenarios about files, tests, and exceptions.

What changes from PCAP-31-03

The former exam had 40 questions across five domains: modules and packages, exceptions, strings, object-oriented programming, then comprehensions, lambdas, closures, and I/O. PCAP-31-04 preserves that foundation, redistributes objectives, and adds a sixth section explicitly connected to the development lifecycle.

Pattern matching and file paths

The new outline names structural pattern matching. Be prepared to read a match/case block, understand pattern order, and recognize the default case. Syntax recall alone is not enough. Practice predicting which branch runs for simple sequences and mappings.

pathlib is also present. Study path construction, composition, common checks, and the difference between representing a path and performing an I/O operation. A useful exercise is to replace platform-dependent string concatenation with Path objects, then test the code in a disposable directory.

Testing and debugging

PCAP-31-04 now expects an understanding of test purpose, test-case organization, and debugging operations. Effective preparation does not require mastering an entire framework beyond the outline. It does require isolating behavior, supplying an input, comparing expected and actual output, and locating the cause of failure.

Build small examples around a pure function, a class, and file reading. Add a normal case, an edge case, and an expected failure. Then use a trace or debugger to follow values and control flow. This connects the new objectives to exceptions and OOP knowledge you already need.

Collaborative work and continuous integration

The syllabus names repositories, branches, code reviews, and continuous integration. PCAP is not becoming an advanced Git administration certification. A candidate should nevertheless recognize why these mechanisms exist: isolate a change, let someone review it, run automated checks, and prevent a broken change from being integrated.

Create a small practice repository. Open a branch, change one function, add a test, and review the diff before merging. Then configure a minimal automated check that runs the tests. This provides concrete experience without confusing Python objectives with full administration of a source-control platform.

AI assistance: validation and data protection

AI assistance appears in the sixth domain, but the exam is not a general artificial-intelligence certification. The objectives focus on critical use: assess a suggestion, verify generated code, and protect data.

Do not copy a proposed solution without review. Ask for a small function in a fictional repository, then inspect types, error handling, boundaries, and tests. Introduce an ambiguous requirement to see whether the suggestion invents behavior. Finally, identify content that must not be submitted: secrets, confidential source, personal data, or unauthorized infrastructure details.

How to adapt preparation already in progress

If you used PCAP-31-03 material, do not discard it. Sort what you learned into three groups: objectives that remain, objectives that moved, and genuinely new objectives. Modules, exceptions, strings, OOP, comprehensions, lambdas, closures, and files all transfer. Replace the old weights, add the new material, and calibrate simulations to 42 questions in 65 minutes.

A simple audit has four steps:

1. read all 42 objectives in blueprint 1.5 and mark each as mastered, needs practice, or new;
2. map each existing resource to a specific objective instead of assuming an old chapter covers the new version;
3. add a lab combining pathlib, tests, a working branch, review, and an automated check;
4. run a timed simulation and analyze mistakes by domain rather than by general confidence.

The currently published OnLevelUp PCAP course still carries the PCAP-31-03 code. It remains useful for the foundation, but this article does not announce a course migration to PCAP-31-04. Until its metadata, domains, and practice exams are updated separately, do not treat them as a blueprint 1.5 simulation.

A four-week study plan

Week 1 — baseline. Review modules, exceptions, and strings. Use short code-reading exercises and check the Python documentation whenever an answer depends on precise behavior.

Week 2 — OOP. Practice attributes, methods, inheritance, resolution, introspection, and representations. Because the domain represents 28.5% and an indicative 12 questions, spread it across several sessions.

Week 3 — advanced constructs and I/O. Connect comprehensions, generators, closures, lambdas, files, and pathlib. Prefer one small, testable project to a disconnected set of snippets.

Week 4 — quality and collaboration. Add tests, debugging, branches, review, CI, and validation of AI suggestions. Finish with a 65-minute session and turn every mistake into a specific follow-up action.

Before buying a voucher

• Confirm that the page displays PCAP-31-04.
• Check the price, tax, and currency in the store for your region.
• Read proctoring, identification, workstation, and connectivity requirements.
• Make sure English works for both code and scenario wording.
• Use blueprint 1.5, not an undated PCAP-31-03 summary.
• Allow for the 15-day wait if a retake is needed.

PCAP-31-04 modernizes an intermediate Python credential by acknowledging the work around code. The goal is not simply to accumulate more syntax: it is to build, verify, explain, and collaborate. A candidate ready for PCAP-31-03 already has a strong base, provided they measure the gap against the six domains that are now active.

One final calibration rule is useful: keep factual exam conditions separate from your own study method. The 42 questions, 65-minute duration, weights, and passing score come from Python Institute. A four-week schedule, practice repository, and suggested lab are preparation techniques, not official requirements. This distinction helps you adapt the plan without accidentally presenting a personal exercise as an exam task.

Official sources

• Python Institute — active PCAP page (opens in a new tab)
• Python Institute — PCAP-31-04 syllabus, blueprint 1.5 (opens in a new tab)
• OpenEDG — voucher store and current options (opens in a new tab)