(2026) Quarkus for beginners, everything you need to know.

Generate your first Quarkos application by selecting the stable version, configuring group and artifact, choosing Maven and Java 17, adding rest and Jackson, then generate, download, and open in IntelliJ.

Open the project in IntelliJ and start the Quarkus app with Maven to compile and run it. Explore DevUI for endpoints and live reload, then visit localhost:8080/hello.

Learn practical REST fundamentals in the Quarkus for beginners course, using get, post, put, and delete to build a complete API with JSON, headers, cookies, and status codes.

Implement a get method to fetch data by creating a games entity with id, name, and category and returning a json list at the /games endpoint.

Understand http headers for pagination in Quarkus APIs, using page and size headers with add header param, returning x total count via response object using builder pattern, tested with Postman.

Learn to implement backend filtering with query parameters in Quarkus using @QueryParam to filter a game list by name, handling optional input and testing results.

Explore how path parameters are embedded in the URL path to identify resources like /users/123 or /product/456. Compare them with query parameters and their role in CRUD.

Implement a path parameter getgame method to retrieve a game by id using @GET, @Path, and @PathParam. Return json via Response.ok for a match, else 404 not found.

Learn how cookies store data to identify users, manage sessions, and remember preferences, while enabling analytics and personalized content, and understand associated privacy considerations and GDPR consent.

Create a cookie to remember the game category a user browses in a non-intrusive way, storing it for 3600 seconds across the whole site to tailor future recommendations.

Learn to read cookies in Quarkus by injecting the game category from the cookie using the cookie-per-um decorator, then sort the paged game list by category.

Explore post, patch, and put http methods to create resources, perform partial updates, and fully replace or create resources at a specific location.

Create a post endpoint with at post and consumes application Jason, using a game object from the body, assign a new id with stream.max, and return a game created message.

Use the patch method to update existing games by annotating the endpoint and implementing updateGame to apply non-null field changes by ID, then verify updates by fetching all games.

Learn how to replace a game object with the put method in Quarkus, using json request and response, and verify updates with a subsequent get.

Learn how to implement a delete operation using the delete method, path parameters, and proper media type annotations, removing a game by id and verifying with a get request.

Define a response model with message, code, and timestamp, including getters, setters, and an auto-generated timestamp. Replace simple text responses and test the JSON output in Postman.

Move global @Consumes and @Produces decorators to the class level to reduce repetition, remove them from methods, and simplify code management in Quarkus.

OpenAPI, formerly Swagger, describes endpoints, http methods, parameters, and data models in a standardized, machine-readable format, with Quarkus auto-generating specs and interactive docs via swagger ui.

Add two dependencies, the Quarkus Small Rhea Open API and Quarkus Swagger UI, to generate and visualize Open API documentation, and configure application.properties to enable it with title, version, description.

Explore Open API and Swagger UI by testing endpoints with Postman. Review data models, endpoints, parameters, and responses, including retrieving all games and a game by ID.

Use the at-schema annotation on pojo class with Open API Library in Quarkers framework to expose schemas in swagger UI and provide descriptions for classes and fields with example values.

Use the At Operation annotation to describe endpoints in detail, specifying outcomes and responses to improve API documentation readability and simplify service integration.

Define and document endpoint responses using ATAPI response annotations, globally setting a 200 response with a JSON schema, and tailor models per endpoint for variants like lists and error codes.

Organize Quarkus endpoints by using the AtTag annotation to tag classes or methods, specifying a name to group endpoints for easier browsing and documentation.

Explore dependency injection in Quarkus, passing dependencies via the CDI to improve modularity and testability while noting potential hidden complexity and configuration costs.

Create a services package and a game service class using dependency injection, with a Test method that prints to console, and annotate with CDI scopes such as at-application-scoped or at-dependent.

Learn to inject a private game service with @Inject in Quarkus, use its methods to retrieve all games, and test the endpoint with swagger to verify console output.

Configure properties with application.properties or application.yml for centralized, environment-specific settings in Quarkus, using defaults and environment variables, with examples like HTTP port.

Explore Quarkus profiles to tailor configuration per environment and load the settings. Activate dev, test, or prod with the quarkus.profile argument to enable hot reload, testing resources, and production optimization.

Configure the config map and inject value using the at-config decorator with the name parameter, then restart with a profile and verify the console outputs the value from configuration file.

Discover how Panache ORM simplifies database interactions in the Quarkis ecosystem by using active record and repository patterns, enabling concise code, typesafe queries, and built-in CRUD with Hibernate.

Configure a Quarkus app to connect to PostgreSQL by adding dependencies (Hibernate ORM Panache, PostgreSQL JDBC driver, and a connection pool) and setting database kind, username, password, and JDBC URL.

Master how ORM maps objects to database tables by creating entities, annotating them with ATT entity, and configuring ID generation with ATT generated value and ATT sequence generator.

Understand how repositories mediate app and database, enabling object‑oriented CRUD without SQL, while Panache auto‑generates persist and find, with application‑scoped injection for a single repository instance.

Inject the repository into the service to fetch all games from the database using the FindAll method, then expose them to the controller via the GetAllGames.

Add a repository method find paginated using Panache find all and page.of to return range of games, improving performance by limiting records, and expose it via a service and controller.

Move sorting logic from the controller to the repository, adding a new parameter sorted by and applying ascending order in find paginated and find all, then propagate through the service.

Add a long count method in the service, delegating to the Games repository's built-in count to obtain the total games, exposed via the controller and the X total count header.

Explore filtering and pagination by game name using the find paginated by name method, supporting page, size, sort by, and name, with service and controller integration.

Explore the like operator to enable partial name matching in database searches, replacing the equals operator in the repository method and appending % wildcards to the name parameter.

learn how to implement a custom count by name method in quarkus, using sql like for partial name matches, and update repository, service, and controller to support optional name filters.

Implement a find-by-id endpoint using the optional result from the games repository to safely handle absent records, and update the controller to query by identifier directly.

Implement create game by setting id to zero, persisting via the repository, and using at transactional, while the controller now calls this new service method.

Move from in-memory replacement to database updates by implementing ReplaceGame that finds a game by id and overwrites it, wrapped in a transactional operation for atomic data integrity.

Introduce an update game method using find by id optional, validates name and category, updates fields, persists the record in a single transaction, and adjusts the controller to call it.

Implement a DeleteGame operation that takes an ID, checks existence with Find by ID, and deletes the record in a transactional scope. Replace the controller with the service implementation.

Clean up code by removing unnecessary methods, variables, and imports in the game service and controller; remove the test variable and its print and the get all games method.

Leverage Flyway within Quarkus to manage database schema versions and migrations—written as SQL scripts or Java code—auto-start at application startup, track history, enable rollbacks, and support multiple schemas.

Add flyway to the project by including the palm.xml dependency for Quarkis flyway, and configure it in application.properties to migrate at startup, set public schemas, and store migrations in ST_main_resources_DB/migration.

Learn how Flyway migrations manage versioned SQL files, like v1_init_table and v2_add_column_to_table, to initialize and evolve database schemas.

Learn how to test database changes using a db viewer to connect to PostgreSQL, and verify migrations with flyway by inspecting the games and flyway_schema_history tables.

Create a GameDon'tExistException as a runtime exception, centralize error handling with global handlers in Quarkas, and use if present or else to provide clear feedback when a game is missing.

Show how to centralize exception handling with a JAX-RS exception mapper that converts specific exceptions into HTTP responses, including a game don't exist exception scenario with 404 not found.

Explore unit, integration, and native tests in Quarkus, showing how unit tests use marking to simulate dependencies and how native tests run in a GralVM native image.

Generate and run unit and integration tests in Quarkus, including a greeting resource in test mode and an integration test variant; use mvn package -P native to run native tests.

Learn to use Marquito to create mock objects in the Java ecosystem, isolate logic from external dependencies, simulate object behavior, verify interactions, and define test scenarios for robust unit tests.

Explore writing a Quarkus unit test with JUnit and Mockito: inject mocks, mock the repository, define findPaginated results, and verify calls and outcomes with assertions.

Learn to write database tests in Quarkus using embedded H2, with test profiles, in-memory schemas, and SQL data loading to validate repository operations and mappings.

Explore how integration tests verify interactions across controllers, services, and repositories, ensuring data flows from http requests to the database in multi-layered applications.