This study plan is designed to help you systematically master the CTFL-AT (Certified Tester Foundation Level - Agile Tester) exam content. By combining focused learning tasks, the Pomodoro Technique (25 min focus + 5 min rest), and Ebbinghaus Forgetting Curve for timely review, you will learn effectively, retain knowledge, and prepare confidently for the exam.

Study Overview

• Duration: 4 Weeks (28 Days)

• Daily Study Time: 4 hours (split into 8 Pomodoro sessions)

• Goals:

  1. Understand Agile Software Development and its core frameworks (Scrum, Kanban, XP).
  2. Master Agile Testing principles, practices (TDD, ATDD, BDD), and processes.
  3. Become proficient in Agile Testing techniques and tools (e.g., Selenium, Jenkins).
  4. Apply CI/CD, automation, and shift-left strategies in testing scenarios.
  5. Practice with sample exam questions and prepare effectively to pass the CTFL-AT certification.

• Tools:

  • Notes App (e.g., Notion, Evernote)
  • Timer App (for Pomodoro sessions, e.g., Toggl or Focus To-Do)
  • Study Resources (Books, CTFL-AT syllabus, video tutorials, practice tests)
  • Testing Tools (e.g., Selenium, JUnit, Jenkins)

Week 1: Agile Software Development

Goal: Develop a strong understanding of Agile concepts, frameworks (Scrum, Kanban, XP), and Agile principles.

Day 1: Introduction to Agile Software Development & Agile Manifesto

• Task 1: Study the background and core concepts of Agile Software Development.

  • Read: “What is Agile Software Development?” (CTFL-AT syllabus or reliable online resources).
  • Focus: Iterative and incremental nature, delivering working software frequently.

• Task 2: Learn the Agile Manifesto:

  • Four core values:
    1. Individuals and interactions over processes and tools.
    2. Working software over comprehensive documentation.
    3. Customer collaboration over contract negotiation.
    4. Responding to change over following a plan.

• Task 3: Study the 12 Agile principles:

  • Write down each principle and create real-life examples to explain them.
  • Example: “Welcome changing requirements” → A project team adjusts features to meet evolving user needs during a sprint.

• Task 4: Create a mind map summarizing the Agile Manifesto and principles.

• Task 5: Reflect and write answers to the following:

  • How do Agile principles improve software delivery?
  • Why is responding to change critical in Agile development?

• Pomodoro Plan: 6 Pomodoro sessions (25 minutes learning + 5 minutes rest).

• End of Day Review: Summarize key points, revise the mind map, and identify knowledge gaps.

Day 2: Scrum Framework - Roles, Events, and Artifacts

• Task 1: Learn about the Scrum framework:

  • Study the 3 core roles:
    • Product Owner (PO): Defines the product backlog and business goals.
    • Scrum Master: Facilitates the Scrum process and removes blockers.
    • Development Team: Delivers the increment of working software.

• Task 2: Study Scrum events:

  • Sprint: Time-boxed iteration (1–4 weeks).
  • Sprint Planning: Define the goal and backlog items for the sprint.
  • Daily Scrum: 15-minute stand-up meeting to discuss progress and blockers.
  • Sprint Review: Inspect the increment and gather feedback.
  • Sprint Retrospective: Discuss improvements for the next sprint.

• Task 3: Understand Scrum artifacts:

  • Product Backlog, Sprint Backlog, Increment.

• Task 4: Draw a Scrum flowchart: Illustrate the entire Scrum process, showing how roles, events, and artifacts interact.

• Task 5: Watch a practical Scrum simulation video online. Take notes on how a Scrum team works day-to-day.

• Task 6: Reflect on these questions:

  • What is the role of the Scrum Master in ensuring smooth sprint execution?
  • How does a Daily Scrum meeting help a team stay aligned?

• Pomodoro Plan: 6 Pomodoro sessions.

• End of Day Review: Write a summary and explain the Scrum flowchart in your own words.

Day 3: Kanban Method

• Task 1: Study the Kanban methodology:

  • Principles:
    1. Visualize workflow.
    2. Limit work in progress (WIP).
    3. Manage flow.
    4. Continuous improvement.

• Task 2: Set up a Kanban board for a testing workflow:

  • Use tools like Trello, Miro, or physical sticky notes.
  • Columns: To-Do, In Progress, In Review, Done.
  • Example workflow: Test design → Test execution → Bug reporting → Fix verification.

• Task 3: Learn about the benefits of Kanban:

  • Managing bottlenecks, improving team focus, and enabling continuous delivery.

• Task 4: Compare Kanban with Scrum:

  • What are the key differences in their workflows and time management?
  • Write a short essay explaining which framework is better for a fast-paced testing team and why.

• Task 5: Practice: Apply Kanban principles to your personal study plan.

• Pomodoro Plan: 6 Pomodoro sessions.

• End of Day Review: Revise your Kanban notes and the comparison with Scrum.

Day 4: Extreme Programming (XP)

• Task 1: Study the Extreme Programming (XP) framework:

  • Key practices:
    • Pair Programming: Two developers collaborate on the same code.
    • Test-Driven Development (TDD): Writing tests before writing code.
    • Continuous Integration (CI): Frequent code integration with automated tests.
    • Refactoring: Improving code structure without changing its behavior.

• Task 2: Write down the benefits and challenges of using XP in an Agile project.

• Task 3: Practical exercise:

  • Try pair programming with a peer or simulate it yourself. Write a simple program using the TDD approach (e.g., a Python function to calculate the sum of two numbers).

• Task 4: Create a table comparing Scrum, Kanban, and XP: Highlight differences in roles, events, and practices.

• Pomodoro Plan: 6 Pomodoro sessions.

• End of Day Review: Summarize XP practices and compare them to Scrum and Kanban.

Day 5: Real-World Scenarios and Practice Questions

• Task 1: Work on real-world Agile scenarios:

  • Analyze case studies where Scrum, Kanban, or XP are applied in testing projects.
  • Write your observations on how the team managed iterations and testing.

• Task 2: Complete 30 practice questions on Agile frameworks, roles, and events.

• Task 3: Review mistakes, write corrections, and clarify any confusing concepts.

• Pomodoro Plan: 6 Pomodoro sessions.

Day 6: Review and Consolidate Knowledge

• Task 1: Review all notes and diagrams created this week.

• Task 2: Revisit the Agile Manifesto, Scrum flowchart, Kanban board, and XP practices.

• Task 3: Summarize the key learning points from each Agile framework.

• Task 4: Complete 15 flashcard reviews to strengthen memory.

• Pomodoro Plan: 6 Pomodoro sessions.

Day 7: Ebbinghaus Review and Self-Reflection

• Task 1: Use the Ebbinghaus Forgetting Curve to revisit all concepts studied this week:

  • Agile Manifesto and 12 Principles.
  • Scrum roles, events, and artifacts.
  • Kanban practices and comparisons.
  • XP principles and TDD exercises.

• Task 2: Take a 20-question quiz to test your understanding. Analyze your score and weak points.

• Task 3: Write a reflection on what you have learned this week:

  • Which framework do you find most useful for Agile Testing? Why?

End of Week 1 Summary
At the end of Week 1, you should have a solid understanding of:

1. Agile Software Development concepts, including the Agile Manifesto and principles.
2. Scrum, Kanban, and XP frameworks with their roles, processes, and key practices.
3. The differences and use cases for each Agile methodology.

Week 2: Fundamental Principles, Practices, and Processes of Agile Testing

Goal: Master the principles of Agile Testing, learn the core practices (TDD, ATDD, BDD), and understand Agile Testing processes, including planning, execution, and collaboration.

Day 8: Agile Testing Principles

• Task 1: Study the 8 Principles of Agile Testing. Write down the meaning and examples of each principle:

  1. Testing is not a phase.
  2. Testing is a whole-team responsibility.
  3. Test early and often.
  4. Prevent defects rather than detecting them.
  5. Continuous feedback loops.
  6. Deliver working software.
  7. Simplify and automate.
  8. Focus on customer needs.

• Task 2: Analyze the differences between Agile Testing principles and traditional testing approaches. Write 2–3 key differences with examples.

• Task 3: Practice identifying how each principle applies in real-world projects:

  • Example: “Test early and often” → Write how testing during sprint planning helps identify risks early.

• Task 4: Summarize the principles into a one-page cheat sheet for quick review.

• Pomodoro Plan: 6 sessions (3 hours of focused study + 1 hour for review and note-making).

Day 9: Test-Driven Development (TDD)

• Task 1: Understand the TDD Red-Green-Refactor process:

  • Red: Write a test that fails.
  • Green: Write the minimal code to make the test pass.
  • Refactor: Improve the code structure without changing its behavior.

• Task 2: Watch a video tutorial or read a guide on TDD in practice.

• Task 3: Hands-on Practice:

  • Write a simple program to calculate the sum of two numbers using TDD.
  • Steps:
    1. Write a test first.
    2. Write the code to pass the test.
    3. Refactor the code and re-run the test.

  Example (in Python):

  def test_addition():  
      assert add(2, 3) == 5  
  
  def add(a, b):  
      return a + b  
  

• Task 4: Reflect on the benefits of TDD:

  • How does TDD improve code quality?
  • What challenges might teams face when adopting TDD?

• Task 5: Write a short explanation of TDD for beginners, using your own words.

• Pomodoro Plan: 6 sessions (focus on learning + hands-on practice).

Day 10: Acceptance Test-Driven Development (ATDD)

• Task 1: Study ATDD concepts and process:

  • Collaboration among developers, testers, and stakeholders to write acceptance tests.
  • ATDD ensures the functionality meets business requirements before coding starts.

• Task 2: Learn Cucumber (BDD tool) and the Gherkin syntax:

  • Gherkin format: Given-When-Then.

• Task 3: Practice creating ATDD scenarios for a login functionality:

  • Example:

    Feature: User Login  
      Scenario: Successful login with valid credentials  
        Given the user is on the login page  
        When the user enters valid credentials  
        Then the user is redirected to the dashboard  
    

• Task 4: Compare TDD and ATDD:

  • Write down the similarities and differences. Use a table format for clarity.

• Task 5: Reflect: How does ATDD improve communication between business stakeholders and the testing team?

• Pomodoro Plan: 6 sessions.

Day 11: Behavior-Driven Development (BDD)

• Task 1: Learn the basics of Behavior-Driven Development (BDD):

  • BDD focuses on system behavior using scenarios written in plain language.

• Task 2: Study the Given-When-Then format in detail:

  • Given: Precondition or setup.
  • When: The action/event being tested.
  • Then: The expected outcome.

• Task 3: Hands-on Practice:

  • Write BDD scenarios for a search functionality:

    Feature: Search Products  
      Scenario: Search for products using a valid keyword  
        Given the user is on the homepage  
        When the user searches for "laptop"  
        Then the search results display a list of laptops  
    

• Task 4: Reflect: How does BDD help bridge the gap between technical and non-technical team members?

• Task 5: Compare BDD and ATDD: Write a short paragraph on when to use each approach.

• Pomodoro Plan: 6 sessions.

Day 12: Integrating TDD, ATDD, and BDD

• Task 1: Revisit TDD, ATDD, and BDD processes. Create a combined summary sheet showing the differences, benefits, and use cases for each approach.

• Task 2: Hands-on Practice:

  • Pick a simple feature (e.g., password reset).
  • Write tests using TDD, ATDD, and BDD to implement the feature.

• Task 3: Reflect: How can a team apply all three techniques together in a project?

• Task 4: Solve 10 practice questions related to Agile testing practices.

• Pomodoro Plan: 6 sessions.

Day 13: Agile Testing Process

• Task 1: Study the Agile Testing Process:

  • Plan: Define test scope and acceptance criteria.
  • Design: Write test cases or automation scripts.
  • Execute: Perform manual and automated testing.
  • Feedback: Collaborate with developers and provide feedback.
  • Retrospective: Reflect and improve testing processes.

• Task 2: Create a flowchart illustrating the Agile Testing Process.

• Task 3: Study how testing integrates with Sprint Planning, Daily Scrum, and Sprint Reviews.

• Task 4: Write examples of how testers collaborate with developers during each phase.

• Pomodoro Plan: 6 sessions.

Day 14: Weekly Review and Ebbinghaus Recall

• Task 1: Use the Ebbinghaus Forgetting Curve to review all concepts studied this week:

  • Agile Testing principles.
  • TDD, ATDD, and BDD.
  • Agile Testing Process.

• Task 2: Solve a 20-question quiz on Agile Testing principles and practices. Analyze your mistakes and clarify doubts.

• Task 3: Reflect on your learning progress:

  • Which topics do you feel confident in?
  • Which areas need further improvement?

• Task 4: Create a list of key takeaways for the week.

• Pomodoro Plan: 6 sessions.

End of Week 2 Summary
At the end of Week 2, you should have:

1. A solid understanding of the Agile Testing principles and processes.
2. Practical knowledge of TDD, ATDD, and BDD with hands-on exercises.
3. The ability to integrate testing approaches into Agile development workflows.

Week 3: Agile Testing Techniques, Tools, and Methods

Goal: Master Agile testing techniques, learn to use testing tools (e.g., Selenium, JUnit, Jenkins), and understand advanced methods like CI/CD, regression testing, and non-functional testing.

Day 15: Exploratory Testing and Pair Testing

• Task 1: Study Exploratory Testing:

  • Definition: Testing that relies on creativity, experience, and intuition without pre-written test cases.
  • Benefits: Dynamic, flexible, and ideal for Agile projects with evolving requirements.
  • Learn to create Test Charters: A simple document outlining what to test, how, and what to look for.

  Example of a Test Charter:

  • Feature: Checkout process for an e-commerce application.
  • Focus: Verify discount coupons and payment behavior.
  • Approach: Add, remove, and apply multiple coupon codes to test edge cases.

• Task 2: Hands-on practice: Perform exploratory testing on a sample web application. Document:

  • What was tested?
  • Issues found? (e.g., wrong calculation, UI bugs).

• Task 3: Study Pair Testing:

  • Pair Testing involves two team members (e.g., developer and tester) working together to test functionality.
  • Benefits: Encourages collaboration, reduces communication gaps, and improves defect discovery.

• Task 4: Reflect on the scenarios where Pair Testing can be most useful.

• Pomodoro Plan: 6 sessions.

Day 16: Regression Testing and Automated Testing

• Task 1: Study Regression Testing:

  • Definition: Ensuring that new code changes don’t break existing features.
  • Focus on why regression testing is critical in Agile (frequent changes and continuous integration).

• Task 2: Learn about Automated Regression Testing:

  • Automate repetitive test cases using tools like Selenium and JUnit.

• Task 3: Hands-on practice:

  • Install Selenium and set up a basic test case for a login form:
    • Open a browser.
    • Enter valid credentials.
    • Verify the successful login message.

  Example Script in Python:

  from selenium import webdriver  
  from selenium.webdriver.common.by import By  
  
  driver = webdriver.Chrome()  
  driver.get("https://example.com/login")  
  
  driver.find_element(By.ID, "username").send_keys("test_user")  
  driver.find_element(By.ID, "password").send_keys("test_pass")  
  driver.find_element(By.ID, "login").click()  
  
  assert "Welcome" in driver.page_source  
  driver.quit()  
  

• Task 4: Reflect on how automated regression tests fit into Agile workflows (integrate with CI/CD).

• Pomodoro Plan: 6 sessions (3 hours learning + 1 hour coding practice).

Day 17: Continuous Integration (CI) and Continuous Delivery/Deployment (CD)

• Task 1: Study Continuous Integration (CI):

  • Definition: Developers frequently integrate code into a shared repository.
  • Key Practices:
    • Automated builds.
    • Automated testing.
    • Immediate feedback.

• Task 2: Learn about Continuous Delivery (CD):

  • Definition: Ensuring software is always in a deployable state.
  • Difference between Continuous Delivery and Continuous Deployment.

• Task 3: Hands-on Practice with Jenkins:

  • Install Jenkins and create a simple CI pipeline.
  • Steps:
    1. Install Jenkins.
    2. Create a job to build a Maven project or run automated tests.

• Task 4: Reflect on how CI/CD pipelines ensure faster and safer releases in Agile.

• Pomodoro Plan: 6 sessions.

Day 18: Shift-Left Testing

• Task 1: Study the concept of Shift-Left Testing:

  • Definition: Moving testing activities earlier in the software development lifecycle.
  • Benefits: Catching defects early reduces costs and enhances collaboration.

• Task 2: Learn how testing integrates during:

  • Requirements analysis (review user stories).
  • Coding (TDD, automated unit tests).
  • Build processes (CI/CD integration).

• Task 3: Reflect: Write a short note on how a shift-left approach improves testing in Agile teams.

• Task 4: Hands-on task: Analyze sample user stories and suggest testable acceptance criteria.

• Pomodoro Plan: 6 sessions.

Day 19: Non-Functional Testing

• Task 1: Learn the key types of non-functional testing:

  • Performance Testing: Ensures system responsiveness.
  • Load Testing: Validates system behavior under high loads.
  • Security Testing: Identifies vulnerabilities.
  • Usability Testing: Tests user-friendliness.

• Task 2: Install and explore JMeter for basic performance testing:

  • Create a load test to simulate 10 virtual users accessing a webpage.

• Task 3: Reflect: Why is non-functional testing critical for ensuring system quality in Agile?

• Pomodoro Plan: 6 sessions.

Day 20: Integrating Tools and Techniques

• Task 1: Integrate the concepts and tools learned so far:

  • TDD for unit testing (JUnit).
  • Regression testing automation (Selenium).
  • CI pipeline setup (Jenkins).
  • Basic load testing (JMeter).

• Task 2: Hands-on practice: Combine all the tools into a simulated testing workflow:

  1. Write a simple Selenium script for login testing.
  2. Integrate the script into Jenkins for automated execution.
  3. Run performance testing using JMeter.

• Task 3: Reflect on how integrating testing techniques and tools improves efficiency and quality.

• Pomodoro Plan: 6 sessions.

Day 21: Weekly Review and Mock Test

• Task 1: Perform a weekly review of all Agile testing techniques, tools, and methods:

  • Exploratory testing and pair testing.
  • Regression testing and automation.
  • CI/CD pipelines.
  • Shift-Left Testing.
  • Non-functional testing.

• Task 2: Solve a 30-question mock test covering all topics studied this week.

• Task 3: Analyze mistakes and create a summary of weak areas.

• Task 4: Use the Ebbinghaus Forgetting Curve: Revisit notes, tools, and code examples.

• Task 5: Reflect: Write down 3 key learnings from this week and identify areas that need further practice.

End of Week 3 Summary

By the end of Week 3, you should:

1. Have a strong grasp of Agile testing techniques, including exploratory, regression, and pair testing.
2. Be proficient in using automation tools (Selenium, JUnit, JMeter).
3. Understand CI/CD concepts and how they integrate with Agile workflows.
4. Be able to implement shift-left testing strategies.
5. Apply testing techniques in both functional and non-functional contexts.

Week 4: Final Review, Practice, and Mock Exams

Goal: Reinforce all concepts, identify weak areas, build confidence through targeted practice, and prepare for the CTFL-AT exam with full-length mock tests.

Day 22: Comprehensive Review – Agile Software Development

• Task 1: Review all content from Week 1:

  • Agile Manifesto (4 values and 12 principles).
  • Scrum Framework: Roles, Events, and Artifacts.
  • Kanban and XP (Extreme Programming) principles and practices.

• Task 2: Revisit your mind maps and notes created for Agile Software Development.

• Task 3: Practice: Solve 15 scenario-based questions related to Agile frameworks (e.g., Scrum events, Kanban WIP).

• Task 4: Write a comparison essay: Scrum vs. Kanban – highlight their use cases in Agile testing projects.

• Task 5: Reflect and clarify any doubts by re-reading weak points.

• Pomodoro Plan: 6 sessions (3 hours review + 1 hour practice).

Day 23: Review – Agile Testing Principles and Practices

• Task 1: Go through the 8 Agile Testing Principles:

  • Simplify and automate.
  • Prevent defects over detection.
  • Deliver working software, etc.

• Task 2: Summarize the key Agile Testing Practices:

  • Test-Driven Development (TDD): Red-Green-Refactor process.
  • Acceptance Test-Driven Development (ATDD): Collaboration and Gherkin scenarios.
  • Behavior-Driven Development (BDD): Given-When-Then syntax.

• Task 3: Hands-on Practice:

  • Write and execute 3 new test scenarios using BDD (Cucumber/Gherkin format).
  • Example scenario: User registration validation.

• Task 4: Solve 20 multiple-choice questions (MCQs) on Agile Testing principles and practices.

• Task 5: Review incorrect answers and note down areas requiring improvement.

• Pomodoro Plan: 6 sessions.

Day 24: Review – Agile Testing Techniques and Tools

• Task 1: Recap key Agile Testing Techniques:

  • Exploratory Testing: When and how to use it.
  • Pair Testing: Benefits and scenarios for applying.
  • Regression Testing: Importance in Agile and automation strategy.

• Task 2: Review tools and their usage:

  • Selenium for automation testing.
  • JUnit for unit testing.
  • Jenkins for CI/CD pipelines.
  • JMeter for basic performance testing.

• Task 3: Hands-on Integration Task:

  • Integrate Selenium scripts into a Jenkins CI pipeline:
    • Write a simple test script for login automation.
    • Trigger the test execution via Jenkins.

• Task 4: Solve 20 technical questions about tools and techniques, including tool-based scenarios.

• Pomodoro Plan: 6 sessions (practical coding + testing).

Day 25: Mock Exam 1 – Full-Length Practice Test

• Task 1: Take a full-length mock exam (90 minutes) with 40–60 questions:

  • Cover all syllabus topics, including Agile Software Development, Testing Principles, Practices, Tools, and Techniques.

• Task 2: Analyze your performance:

  • Mark the incorrect answers and note down explanations for each.
  • Categorize mistakes into:
    • Conceptual errors.
    • Testing tool-related errors.
    • Scenario misunderstanding.

• Task 3: Review the weakest areas and revisit relevant notes and examples.

• Task 4: Reflect: Write down three action points to improve your weak areas before the next test.

• Pomodoro Plan: 6 sessions (1.5 hours for the mock test + 2.5 hours for review).

Day 26: Targeted Improvement and Practice

• Task 1: Focus on weak areas identified from the mock test:

  • If Agile Testing principles were weak → Review examples and notes.
  • If tools (Selenium/Jenkins) were challenging → Re-do practical exercises.

• Task 2: Revisit all key diagrams and mind maps:

  • Scrum Flowchart, Kanban Board, Agile Testing Process.
  • TDD/ATDD/BDD process diagrams.

• Task 3: Practice targeted questions:

  • Solve 15 questions specifically from weak areas.
  • Write out explanations for correct answers to reinforce understanding.

• Task 4: Reflect: How much progress have you made this week? Identify remaining gaps.

• Pomodoro Plan: 6 sessions.

Day 27: Mock Exam 2 – Final Practice Test

• Task 1: Take the final full-length mock exam (90 minutes):

  • Ensure you create a quiet exam environment with no distractions.
  • Time yourself to practice time management.

• Task 2: Score the test and analyze:

  • Calculate your overall performance and improvement since Mock Exam 1.
  • Identify any last-minute weak areas.

• Task 3: Review notes, summaries, and practice tests.

• Task 4: Reflect: Write down what you’ve learned, and prepare a checklist for exam day.

• Pomodoro Plan: 6 sessions (1.5 hours for the mock test + 2.5 hours review).

Day 28: Final Review and Exam Day Preparation

• Task 1: Conduct a comprehensive final revision of all syllabus topics:

  • Agile Software Development: Manifesto, frameworks, and principles.
  • Agile Testing Principles: Testing as a team effort, test early, focus on automation.
  • Testing Practices: TDD, ATDD, BDD processes.
  • Techniques: Regression testing, exploratory testing, pair testing.
  • Tools: Selenium, JUnit, Jenkins, JMeter.

• Task 2: Revise key diagrams, flowcharts, and notes:

  • Use your mind maps, flowcharts, and cheat sheets for quick recall.

• Task 3: Light practice: Solve 10 easy questions to warm up without overloading your mind.

• Task 4: Prepare for the exam:

  • Organize all required materials (ID, test confirmation, etc.).
  • Create a checklist of tips:
    • Read questions carefully.
    • Manage your time: 90 minutes = ~1.5 minutes per question.
    • Mark tricky questions and return to them later.

• Pomodoro Plan: 6 sessions.

End of Week 4 Summary

At the end of Week 4, you will have:

1. Completed two full-length mock exams to assess your readiness.
2. Revisited and reinforced all CTFL-AT syllabus topics.
3. Identified and improved weak areas through targeted practice.
4. Gained confidence in Agile Testing tools and techniques.
5. Prepared strategically to maximize performance on the exam day.

Final Exam Day Checklist

1. Sleep well the night before.
2. Review your cheat sheets and key notes briefly.
3. Arrive early to the test center or set up your test environment for online exams.
4. Manage your time wisely during the exam.
5. Stay calm and confident—you’ve prepared thoroughly!