Java Backend Development with Quarkus (Turnkey)

// Product entity with Panache Active Record
@Entity
@Table(name = "products")
public class Product extends PanacheEntityBase {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    public Long id;

    @Column(nullable = false, length = 255)
    public String name;

    @Column(unique = true)
    public String slug;

    @Column(precision = 10, scale = 2)
    public BigDecimal price;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "category_id")
    public Category category;

    public boolean isActive = true;

    @Column(columnDefinition = "jsonb")
    @Type(JsonType.class)
    public Map<String, Object> attributes = new HashMap<>();

    // Static Panache methods
    public static List<Product> findActive() {
        return list("isActive", true);
    }

    public static Page<Product> findActiveByCategory(Long categoryId, int page, int size) {
        return find("category.id = ?1 and isActive = true", categoryId)
                .page(page, size);
    }
}

Resources (controllers) are implemented with RESTEasy Reactive, which natively supports non-blocking operations:

@Path("/api/v1/products")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@ApplicationScoped
public class ProductResource {
    @Inject
    ProductService productService;

    @GET
    @Authenticated
    public Response list(
            @QueryParam("page") @DefaultValue("0") int page,
            @QueryParam("size") @DefaultValue("20") @Max(100) int size,
            @QueryParam("category_id") Long categoryId) {
        PanacheQuery<Product> query = categoryId != null
                ? Product.find("category.id = ?1 and isActive = true", categoryId)
                : Product.find("isActive", true);
        List<Product> products = query
                .page(page, size)
                .list();
        long total = query.count();
        return Response.ok(new PagedResponse<>(
                products.stream().map(ProductDto::from).toList(),
                page,
                size,
                total
        )).build();
    }

    @POST
    @RolesAllowed("admin")
    @Transactional
    public Response create(@Valid CreateProductRequest request) {
        Product product = productService.create(request);
        return Response.status(Response.Status.CREATED)
                .entity(ProductDto.from(product))
                .build();
    }

    @GET
    @Path("/{id}")
    public ProductDto get(@PathParam("id") Long id) {
        return Product.findByIdOptional(id)
                .map(ProductDto::from)
                .orElseThrow(NotFoundException::new);
    }

    @DELETE
    @Path("/{id}")
    @RolesAllowed("admin")
    @Transactional
    public Response delete(@PathParam("id") Long id) {
        boolean deleted = Product.deleteById(id);
        return deleted ? Response.noContent().build() : Response.status(404).build();
    }
}

How to Configure Security?

We configure security via SmallRye JWT. Configuration in application.properties:

mp.jwt.verify.publickey.location=META-INF/resources/publicKey.pem
mp.jwt.verify.issuer=https://myapp.com
quarkus.http.auth.permission.authenticated.paths=/api/v1/*
quarkus.http.auth.permission.authenticated.policy=authenticated
quarkus.http.auth.permission.public.paths=/api/v1/auth/*,/api/v1/products
quarkus.http.auth.permission.public.policy=permit

What Does Native Compilation Provide?

We configure native build once in CI/CD. Build command:

./mvnw package -Pnative -DskipTests # or via Docker ./mvnw package -Pnative -Dquarkus.native.container-build=true 

At production startup, you get a binary that launches in milliseconds. This is especially important for Serverless functions and ephemeral pods in Kubernetes.

Case Study: E-Commerce Backend on Quarkus

We implemented a catalog with filtering and a shopping cart for a major retailer. The original Spring Boot project started in 8 seconds, consumed 400 MB RAM. After migration to Quarkus native: cold start 0.05 s, memory 45 MB. A cheap 2-core, 4 GB RAM server handles a peak load of 1000 RPS. Cloud savings were 4× — over $4000 per month.

Work Process

1. Requirements analysis and technical specification. We capture API, entity, and integration requirements.
2. Project setup: Quarkus 3.x, Java 21, PostgreSQL, Redis, Docker Compose.
3. Entity and resource development using Panache and RESTEasy Reactive.
4. Authorization implementation (JWT, OAuth2, Keycloak).
5. Integration with external services via REST or message queues.
6. Writing tests (QuarkusTest + RestAssured).
7. CI/CD configuration with native build and Kubernetes deployment.
8. Delivery of documentation, repository, credentials, and team training.

What's Included

• REST API development with OpenAPI documentation
• Authorization setup (JWT, OAuth2, Keycloak)
• Database migrations (Flyway/Liquibase)
• Integration with message queues (Kafka, RabbitMQ) and cache (Redis)
• Test writing (QuarkusTest + RestAssured)
• CI/CD pipeline with native build and Kubernetes deployment
• Delivery of repository, documentation, credentials, and training for the client's team

Estimated Timelines

Contact us for a project assessment. Get a consultation on migrating from Spring Boot or starting a new project. We guarantee transparent timelines and results that meet Core Web Vitals.