Vadym Kazulkin 🇺🇦’s Post

New blog post alert 🚨 "Serverless applications on AWS with Lambda using Java 25, API Gateway and Aurora DSQL – Part 1 Sample applications". In this article series, we’ll explain how to implement a serverless application on AWS using Lambda with the support of the released Java 25 version. One application uses JDBC and another Hibernate, both with Aurora DSQL. If you like my content, please follow me on GitHub (github.com/Vadym79) and give my repositories like this https://lnkd.in/epud2eRf a star! Maximilian Schellhorn Andrei Shakirin Lefteris Karageorgiou Matt Meckes Yuriy Bezsonov Raluca Constantin Philipp Page James Ward Amazon Web Services (AWS) Oracle #Java #Serverless #AuroraDSQL #PostgreSQL https://lnkd.in/eMSzrJGy

New blog post alert 🚨 "Serverless applications on AWS using Lambda with Java 25, API Gateway and DynamoDB – Part 2 Initial performance measurements". In this article, we’ll perform Lambda function initial performance measurements of the sample application using Lambda with Java 25 API Gateway and DynamoDB without any optimizations. If you like my content, please follow me on GitHub (github.com/Vadym79) and give my repositories like this https://lnkd.in/epud2eRf a star! Amazon Web Services (AWS) Oracle #Java #Serverless https://lnkd.in/ejJYXn_4

New blog post alert 🚨 "Serverless applications on AWS using Lambda with Java 25, API Gateway and Aurora DSQL – Part 2 Initial performance measurements". In this article, we’ll perform Lambda function initial performance measurements of the sample application using Lambda with Java 25 API Gateway and Aurora DSQL without any optimizations. If you like my content, please follow me on GitHub (github.com/Vadym79) and give my repositories like this https://lnkd.in/epud2eRf a star! Amazon Web Services (AWS) Oracle #Java #Serverless #PostgreSQL https://lnkd.in/grbkixBZ

Built a modular microservice platform combining Job, Company, and Review services using Spring Boot, PostgreSQL, and Docker. Each service manages its own data but communicates via APIs.

Building Java serverless applications on AWS can be efficient, even with concerns about slow cold starts. A recent AWS Architecture Blog provides insights on deploying Quarkus-based applications on AWS Lambda using AWS SAM, merging cloud-native Java with serverless infrastructure. Key takeaways include: - **Quarkus + GraalVM native images**: Quarkus compiles Java applications into native binaries, which reduces startup time and memory usage—making it ideal for Lambda environments. - **Reduced cold start latency**: Native builds enhance Lambda initialization time, allowing Java workloads to perform better in serverless architectures. - **AWS SAM simplifies deployment**: The AWS Serverless Application Model (SAM) enables developers to build, package, and deploy serverless applications with straightforward commands like `sam build` and `sam deploy`. - **Flexible integration with custom runtimes**: SAM supports the integration of frameworks like Quarkus through custom runtime configurations and Makefile-based builds. As a result, Java developers can create high-performance serverless APIs using familiar tools such as Maven, Amazon API Gateway, and AWS Lambda without needing to change their programming language. This is a great example of how modern JVM frameworks are adapting for cloud-native and serverless workloads. Read the full blog: https://lnkd.in/g4niaj_2 #AWS #Java #Quarkus #Serverless #AWSLambda #CloudArchitecture #AWS SAM #CloudNative

Spring Framework Learning Roadmap I’ve been strengthening my knowledge in the Spring Ecosystem, which is one of the most powerful frameworks for building Java-based enterprise applications. 📌 Key areas I am focusing on: 🔹 Spring Core & Spring MVC – Dependency Injection, Annotations, Scheduling 🔹 Spring Boot – Auto-configuration & production-ready applications 🔹 Spring Data & Hibernate – JPA, JDBC, Transactions, Entity Lifecycle 🔹 Databases – MySQL, PostgreSQL, MongoDB (Queries, Joins, Indexing, Locking) 🔹 Spring Security – OAuth2, Form Authentication, Basic Auth, JWT 🔹 Testing – JPA Test, MockMVC, Service Testing 🔹 Microservices Architecture – Docker, Spring Cloud, API Gateway, Eureka 🔹 Message Queues – Kafka, RabbitMQ, AWS SQS This roadmap helps in understanding how different components of the Spring ecosystem work together to build scalable, secure, and production-ready applications. Always learning and improving! 💻 #Java #SpringBoot #SpringFramework #Microservices #BackendDevelopment #Hibernate #SpringSecurity #Kafka #SoftwareDevelopment

💡 How We Reduced Microservice Latency by 70% in a Java + Spring Boot System One of the biggest challenges in large-scale microservices systems is service-to-service latency. In one of our systems, we had this flow: Client → API Gateway → Service A → Service B → Service C → Database The response time was ~1.8 seconds, which was unacceptable for a high-traffic application. After analyzing the architecture, we implemented 4 changes: 1️⃣ Introduced Redis caching Frequently requested data was cached instead of hitting the database repeatedly. 2️⃣ Replaced synchronous calls with Kafka events Instead of blocking REST calls between services, we used event-driven communication. 3️⃣ Added database query optimization Indexes + query refactoring significantly reduced DB execution time. 4️⃣ Enabled asynchronous processing Non-critical operations were handled using message queues and background workers. 📊 Results Response time: 1.8 seconds ➜ ~500 ms System throughput improved significantly during peak traffic. Modern backend systems are not just about writing APIs — they’re about designing scalable distributed architectures. Curious to know how others are optimizing microservices performance in Java systems. What techniques worked best for you? #Java #SpringBoot #Microservices #SystemDesign #SoftwareArchitecture #BackendEngineering #Kafka #AWS #CloudArchitecture #ScalableSystems

New blog post alert 🚨 "AWS Lambda Managed Instances with Java 25 and AWS SAM – Part 6 Lambda function performance improvement approaches". In this article, we’ll optimize our Lambda function to improve the cold start time significantly. Amazon Web Services (AWS) Oracle #Java #Serverless #AWSLambda #performance https://lnkd.in/ehASnK6m

Java on AWS Lambda often faces criticism for cold starts and large deployment sizes, but with the right approach, it can be lean, fast, and surprisingly cost-efficient. A recent AWS article highlights how to effectively run “oversized” JVM-based Lambdas using Amazon Corretto alongside Quarkus. Key insights from the post include: - Large Java Lambdas are viable: A full MicroProfile application with multiple REST endpoints can operate within a single Lambda without significant performance penalties. - Build-time optimizations matter: Frameworks like Quarkus shift heavy work to build time, which reduces reflection and enhances startup performance. - Cold vs warm performance: Example results indicated approximately 3 seconds for the first cold start, but only 5–6 ms for warm requests. - Cost efficiency: With moderate traffic, a Java Lambda running on ARM-based Graviton processors can incur costs of only a few dollars per month, depending on workload. - Portable architecture: The same application can function locally, in containers (ECS/EKS), or on Lambda without requiring code changes. The bigger takeaway is that serverless doesn’t always equate to tiny functions. With modern JVM tooling, it is possible to run full Java microservices on Lambda while effectively managing performance and costs. Read the full AWS blog: https://lnkd.in/g_VrG_34 #AWS #Java #Serverless #AWSLambda #AmazonCorretto #Quarkus #CloudArchitecture #Microservices

Running Java microservices on Kubernetes is becoming standard for cloud-native architectures. A recent AWS Containers blog provides insights on deploying Quarkus applications to Amazon EKS, merging modern Java frameworks with managed Kubernetes. Key highlights from the guide include: - Quarkus is built for cloud-native workloads, offering fast startup times and low memory usage, making it ideal for containerized microservices and rapid scaling scenarios. - Container-first development allows the application to be packaged as a container image and pushed to Amazon Elastic Container Registry (ECR) before deployment to the Kubernetes cluster. - Kubernetes resources are generated automatically using the Quarkus Kubernetes extension, enabling developers to create resources like Deployment, Service, and Ingress during the Maven build process. - Secure access to AWS services is facilitated through IAM Roles for Service Accounts (IRSA), allowing pods to access services like Amazon DynamoDB without storing credentials in containers. - Infrastructure as Code with AWS CDK is showcased, deploying infrastructure including a VPC, Amazon EKS cluster, ECR repository, DynamoDB table, and EventBridge bus. The big takeaway is that modern Java frameworks like Quarkus simplify the process of building Kubernetes-native applications, while services like Amazon EKS manage cluster operations and scaling. Read the full blog: https://lnkd.in/gg9s6JEG #AWS #Java #Quarkus #Kubernetes #AmazonEKS #CloudNative #Microservices #Containers