SoftwareTestPilot
Signature course

Cucumber BDD with Java

Turn agreed examples into readable Cucumber scenarios for a synthetic shopping cart: example mapping, declarative Gherkin, outlines, Java step definitions with custom parameter types, PicoContainer state, hooks, reports, CI and a deliberate pricing mutation. Complete Maven source; website checkpoints check notes, not Maven runs. A practical path from an example map to readable, failing-when-wrong Cucumber scenarios in Java.

24
Lessons
8
Sections
8
Practice labs
~12h
Of content

Sign in to save progress and earn a verified achievement.

cart.feature
1Scenario: Coupon applies before free shipping
2 When I add 1 of "lamp"
3 And I apply coupon "SAVE10"
4 Then the discount is 114.80
5 And the total is 1033.20
6
Reference projectCucumber 7 · Java · Maven

The method

Built like real QA work, not a video playlist.

Learn

24 focused lessons, each a few minutes long.

Practice

8 hands-on labs in a browser workspace.

Test yourself

8 section assessments plus a final exam.

Prove it

A public, verifiable achievement for recruiters.

What you will learn

  • BDD foundations and discovery: Decide what BDD is for on your team, Reconstruct the pinned Maven reference, Run example mapping before writing Gherkin
  • Writing good Gherkin: Write declarative, business-level steps, Use Background and tags with restraint, Use Scenario Outline for data, not for everything
  • Step definitions in Java: Bind steps with Cucumber expressions, Add custom parameter types and data tables, Assert observable outcomes in Then steps
  • State, hooks and dependency injection: Share per-scenario state with PicoContainer, Use hooks for setup and evidence, not hidden logic, Keep test data isolated and repeatable
  • Cucumber with Selenium and APIs: Connect steps to page objects, Drive API scenarios through a client layer, Choose the right layer for each scenario
  • Running, reporting and CI: Configure the JUnit Platform runner, Produce reports people can read, Run Cucumber in CI and in parallel safely

Where you will be at the end

  • Complete 8 hands-on practice challenges, one per section (from BDD foundations and discovery to Mutation, retest and portfolio)
  • Pass 8 section assessments
  • Pass the Cucumber BDD with Java final assessment and add the result to your Skill Passport

Who this course is for

  • Beginners and manual testers starting this skill from scratch
  • Working testers who want to apply it on real projects
  • Anyone preparing for QA interviews that ask about this skill
  • Best if you already have: Basic Java (classes, methods, exceptions); Java 17+ and Maven 3.9+ installed; terminal familiarity

Curriculum

9 sections, one clear path.

LessonPracticeKnowledge checkProjectAssessment
    • Decide what BDD is for on your team
    • Knowledge check
    • Reconstruct the pinned Maven reference
    • Knowledge check
    • Run example mapping before writing Gherkin
    • Knowledge check
    • Contract evidence: BDD foundations and discovery
    • Section assessment

Members-only toolkit

Take the course with you

Made from this course's own lessons, quizzes and labs — ready to revise before interviews or use at work.

Course cheat sheet

Loading…

Interview Q&A pack

Loading…

Lab solutions & hints

Loading…

  • Auto-checked labs
  • Capstone portfolio project
  • Timed final exam

Why paid courses

More than a free course: practice, proof and a portfolio

What you getFreeAcademy
Short lessons with examples
Quick checks and certificate
Hands-on labs checked automatically
Section tests and a timed final exam
Portfolio capstone project with milestones
Cheat sheet, interview pack and lab answers to download
Verified skills on your profile and Skill Passport

What Students Are Saying

Sign in and complete 20% of the course to leave a review.

Share your experience on Trustpilot (optional)

Honest feedback is welcome, whatever your experience. A Trustpilot review is not required for your certificate.

Cucumber BDD with Java: common questions

1.Do I need experience before starting Cucumber BDD with Java?
Basic Java (classes, methods, exceptions). Java 17+ and Maven 3.9+ installed; terminal familiarity.
2.What can I try for free, and what needs payment?
2 preview lessons are open to everyone. Full access to every lesson, lab and assessment is a one-time payment. The current price, and any offer that is still running, is shown in the access panel on this page and confirmed again at checkout.
3.How long does the course take?
About 12 hours of lessons and labs, fully self-paced. Your progress is saved automatically so you can stop and continue any time.
4.What do I get when I finish?
Passing the final assessment gives you a verifiable achievement page you can share, and the result is added to your Skill Passport.

Finish with proof, not just a certificate PDF.

Pass the final assessment and get a public verification page showing your score, completion date and the skills you demonstrated — ready to share on LinkedIn.

Course guide

About this Cucumber BDD with Java course

Teams adopt Cucumber hoping product, development and QA will finally share one description of how the system behaves. Many end up with slow, brittle suites of click-by-click Gherkin that nobody outside QA reads. This course works through a small synthetic shopping cart with three clear rules: a quantity limit of one to ten, a SAVE10 coupon worth ten percent, and free shipping from 999 rupees after discount. Twenty-four lessons in eight sections take those rules from an example-mapping conversation to executable scenarios, Java step definitions, reports and CI. Eight written checkpoints and eight assessments use the existing Academy format.

The course starts with discovery rather than syntax. Example mapping separates the story, its rules, concrete examples and open questions, so that scenarios are written only after the team agrees what should happen. You then write declarative Gherkin: business-level steps, one behaviour per scenario, a short Background, meaningful tags and Scenario Outlines only where the steps stay the same and data changes. Each lesson shows a concrete artifact from the cart example and names the common mistake it avoids.

On the Java side you bind steps with Cucumber expressions, add a custom rupees parameter type that converts money to integer paise, read a DataTable into the catalogue and keep assertions in Then steps. Scenario state is shared through a small World class injected by PicoContainer, with a fresh instance per scenario and no static fields. Hooks are used for setup and failure evidence, never to hide business steps. Lessons on Selenium page objects and API client layers explain how the same structure scales, and are clearly labelled as extensions rather than part of the runnable project.

The complete source-map lesson includes a Maven pom, the Cart class, a JUnit Platform suite runner, the World class, step definitions, the feature file and a README. Cucumber is pinned to 7.20.1 with JUnit 5.11.4, and the project needs Java 17 or newer and Maven 3.9 or newer. Running mvn test executes five scenarios, because the outline expands into two rows, and writes HTML and JSON reports under target. We ran this exact project before publishing: all five scenarios passed, the smoke tag ran one scenario, and the deliberate BREAK_RULE mutation failed the coupon scenario with expected 11480 but was 22960.

Later sections cover the runner configuration, readable reports, CI stages, safe parallel execution and living documentation. You learn to spot smells such as conjunction steps, giant outlines and duplicated step wording, and to review feature files like code. The final portfolio contains an example map, the feature, step definitions, a passing run, the failing mutation run, the restored retest and the report. Website checkpoints validate a completed written note and do not run Maven. The certificate records Academy completion, not an official Cucumber certification.

Who this course is for

  • Manual testers moving into BDD automation with Java
  • Selenium Java engineers adding Cucumber to a framework
  • QA engineers who want feature files the business can read

What you need

  • Basic Java (classes, methods, exceptions)
  • Java 17+ and Maven 3.9+ installed
  • Terminal familiarity

What you will be able to do

  • Run example mapping and turn agreed examples into declarative scenarios
  • Write Java step definitions with custom parameter types and shared state
  • Produce HTML and JSON reports and run tagged suites in CI
  • Prove scenarios fail on a deliberate defect and retest the fix