Josip Medic

A production-ready, cloud-native microservices architecture demonstrating modern back-end development practices with reactive programming, event-driven design, and comprehensive observability.

This project showcases a complete microservices ecosystem built with Kotlin and Spring Boot WebFlux, featuring fully reactive, non-blocking communication patterns. The system demonstrates enterprise-grade patterns, including API gateway routing, event-driven architecture with Kafka, distributed tracing, and comprehensive monitoring.

Key features:

• 100% reactive: End-to-end non-blocking architecture using Spring WebFlux and R2DBC.
• Modern API gateway: Armeria-based gateway with gRPC support, rate limiting, and circuit breakers.
• Event-driven communication: Asynchronous inter-service communication via Kafka.
• Full observability stack: Integrated OpenTelemetry, Jaeger, Zipkin, Tempo, Grafana, and Prometheus.
• Production-ready features: Includes health checks, metrics, distributed tracing, and proper error handling.
• Type-safe database access: JOOQ integration with automatic schema generation from Flyway migrations.
• Container-first approach: Complete Docker Compose setup for local development and testing.

A comprehensive showcase of Scala 3, ZIO 2, and Tapir demonstrating modern functional programming patterns, reactive architectures, and production-ready practices. This multi-module project features REST API development, stream processing with Kafka, type-safe database access, and JWT-based authentication.

Core capabilities:

• REST API server: Type-safe HTTP endpoints using Tapir with automatic OpenAPI/Swagger documentation.
• User management: Complete authentication system with JWT tokens, password recovery, and email notifications.
• Product and review system: CRUD operations for products and reviews with relational data modeling.
• Kafka streaming: Producer implementation with ZIO Streams for processing large datasets.
• Database access: Type-safe SQL queries using Quill with connection pooling.
• Error handling: Comprehensive error types with proper HTTP status code mapping.

ZIO ecosystem features:

• ZLayer dependency injection: Compile-time verified dependency graph
• ZIO streams: Declarative stream processing with backpressure
• ZIO logging: Structured logging with SLF4J integration
• ZIO configuration: Type-safe configuration loading with automatic derivation
• ZIO Kafka: Reactive Kafka client integration

A restful Scala Play framework 2.4 application using Akka, Reactive Slick 3.0, Akka Actors for ActionLogs, JWT Token user identification and authentication, DDD domain validation, and Guice Dependency Injection

This is a sample application using Scala, PlayFramework, and Postgres.


- Slick FRM for DB connection
- Akka Actors for ActionLog
- Deep validation where all errors, warnings, and info messages are collected and presented
- All REST responses are unified with the same structure every time, so it's easier to handle errors, warnings, and messages as well as specific data on pages.

Responses are structured for global and local messages. Local messages are coupled to some field, e.g., "Username is too long. Allowed length is 80 chars." Global messages are messages that reflect all data on page, e.g., "User will not be active untill is approved." Messages have three levels: ERROR, WARNING and INFORMATION.

(example response: http://demo3385913.mockable.io/api/v1/single-create-response)


- JSON Web Tokens (JWT) for user identification and authentication
- Divided into modules, e.g., user module, organization-structure module, etc. Each module has DAO, domain, validation, and service packages
- Spring dependecy injection

The problem is to find all unique configurations of a set of normal chess pieces on a chess board with dimensions M×N where none of the pieces is in a position to take any of the others. Assume the colour of the piece does not matter, and that there are no pawns among the pieces. Write a program which takes as input:

- The dimensions of the board: M, N.
- The number of pieces of each type (King, Queen, Bishop, Rook and Knight) to try and place on the board.

As output, the program should list all the unique configurations to the console for which all of the pieces can be placed on the board without threatening each other. When returning your solution, please provide with your answer the total number of unique configurations for a 7×7 board with 2 Kings, 2 Queens, 2 Bishops and 1 Knight.

National Champion of Croatia in the Red Bull Paper Wings contest in 2009 and participant in the Red Bull Paper Wings World Championships in Salzburg, Austria, where I took 43rd place.

National Champion of Croatia in the Red Bull Paper Wings contest in 2012 and participant in the World Championships in Salzburg, Austria, where I took 20th place.