Stijn Van Bael’s Post

🚀 Excited to share that JsonApi4j 1.5.0 is now live! 👉 https://lnkd.in/eSgd4sbs This release adds built-in caching to the Compound Documents Resolver - fewer downstream calls, faster responses for repeated include queries. How it works: → The resolver caches individual resources by resource type + id → On the next request, only cache misses trigger HTTP calls → Cache entries respect standard HTTP Cache-Control headers (max-age, no-store, etc.) → The final compound document response carries an aggregated Cache-Control header - the most restrictive directive across all included resources In-Memory Cache implementation is enabled by default - zero configuration needed. For distributed deployments, you can plug in your own implementation via the SPI, for example one for Redis. --- JsonApi4j is an open-source framework for building APIs aligned with the JSON:API specification, with a strong focus on developer productivity and clean architecture. If you're looking for a structured and flexible way to expose JSON:API endpoints — give it a try. Feedback and contributions are always welcome! 🙌 #java #jsonapi #opensource #api #caching

We wrote 60,000 lines of Rust to power a TypeScript framework, and are now sharing what that journey actually looked like. The runtime handles everything underneath your application code - HTTP, databases, pub/sub, tracing, caching, API gateway - all running multi-threaded in the same process as Node.js. Give it a read: https://lnkd.in/dd-bwM-J

One of the biggest technical bets we've made at Encore, and it's paying off every day. The post goes into the full story.

This article from Encore is a really interesting use case of portability, I really liked the fun part "Pingora didn't support Windows when we started using it, and since Encore needs to run on Windows for local development, we added Windows support to Pingora and contributed it upstream. So today Pingora runs on Windows thanks to Encore. 🙌"

Lately, my teammates and I have been diving deep into the inner workings of Operating Systems—studying process states, concurrency, and thread scheduling. Instead of just reading about these concepts, we decided to put the theory into practice by building a system that actually relies on them. I’m incredibly proud to share that our team just finished engineering a fault-tolerant Distributed File System (DFS) from scratch using Java! 🚀 Instead of relying on heavy abstractions or frameworks like Spring Boot, we wanted to understand the raw mechanics of how enterprise storage systems (like HDFS or AWS S3) manage data, network traffic, and hardware failures. Here is what we built under the hood: ⚡ Custom TCP Protocol: Bypassed REST entirely for internal node communication, utilizing raw TCP Sockets for ultra-low latency binary streaming. 🧠 Concurrent Memory Safety: Designed the Master Node using a ConcurrentHashMap and thread pools to handle asynchronous web requests with constant-time lookups and zero memory corruption. 🔄 Auto-Recovery & Fault Tolerance: Engineered a replication algorithm (Factor of 3) with background Heartbeat daemons. If a Data Node OS process is terminated mid-operation, the Master instantly detects the failure and self-heals the download using backup replicas. 📊 Real-Time Visual Dashboard: Built a decoupled, asynchronous JavaScript/HTML/CSS frontend to map file chunks and monitor live node health. Building this collaboratively forced us to navigate complex systems engineering challenges together—from breaking network socket buffer deadlocks to managing disk I/O with Java NIO. It was an incredible way to bridge the gap between OS theory and real-world distributed architecture, and I couldn't have asked for a better team to build this with! 🤝 A huge shoutout to Harkeerat Singh and Niharika Berry for the late-night debugging sessions and brilliant code contributions. If you want to see the code or run a "Chaos Monkey" test on our cluster yourself, check out the repository here: https://lnkd.in/g7pJP7Zf #SoftwareEngineering #Java #DistributedSystems #ComputerScience #Networking #BackendEngineering #Teamwork #SystemsDesign

5 Spring Boot annotations I use every single day in production: 𝟭. @RestController Combines @Controller + @ResponseBody. Every API endpoint class starts here. 𝟮. @Service Marks your business logic layer. Controllers stay thin, services stay fat. 𝟯. @Transactional Wraps a method in a database transaction. If anything fails — everything rolls back. Non-negotiable for payment flows. 𝟰. @Cacheable Caches method results (we use it with Redis). First call = DB hit. Every call after = instant cache response. 𝟱. @KafkaListener Listens to a Kafka topic and processes events. This is how our microservices communicate without tight coupling. Example: @KafkaListener(topics = "ticket-created", groupId = "crm-group") public void handleTicket(TicketEvent event) {   notificationService.sendAlert(event); } These 5 annotations alone cover 80% of what I write daily. Which annotation do you find most useful? Drop it below 👇 #SpringBoot #Java #BackendDevelopment #Microservices #JavaDeveloper

Building scalable systems is challenging, but testing those limits is the best way to learn. Over the past couple of weeks during my SIWES, I decided to dive deep into systems architecture, security, and high-concurrency environments. To bridge the gap between my current Python/Django expertise and my company’s C#/ASP.NET stack, I built a high-concurrency event ticketing backend -essentially a mini-Ticketmaster! 🎟️ Here is what I engineered: 🔹 Concurrency Safety: Solved the dreaded "double-booking" race condition using PostgreSQL pessimistic locking (select_for_update()). 🔹 Read-Heavy Optimization: Implemented Redis caching to shield the DB from traffic spikes, paired with strict cache invalidation to keep data accurate. 🔹 Asynchronous Processing: Decoupled slow processes using Celery & message brokers so the API stays lightning-fast while emails queue in the background. 🔹 API Defense: Built strict throttling/rate limiting to block scalper bots from spamming the purchase endpoints. 🔹 Containerization: Orchestrated the entire multi-server architecture with Docker and docker-compose. I also spent time deploying a CRUD blog app to Azure and building a new portfolio using HTML/CSS/Python. Next up: Taking these exact same architectural concepts --caching, locking, rate limiting, and containerization --and translating them into ASP.NET. #SoftwareEngineering #BackendDevelopment #Django #Redis #Docker #PostgreSQL #ASPNET #SIWES #TechJourney

I hid a Lua script inside a DLL. Here's why. My distributed rate limiter needed a Lua script to run atomic operations in Redis. The naive approach: hardcode it as a C# string literal. private const string LuaScript = @" local current = redis.call('GET', KEYS[1]) ... "; It works. But it's terrible to maintain. No syntax highlighting. No IDE support. No separate version history. One big ugly string sitting in the middle of your C# class. So I did something different. I created a separate sliding-window.lua file. Proper syntax highlighting in the IDE. Its own version history in Git. Readable, editable, testable in isolation. Then I embedded it directly into the DLL as an assembly resource. var assembly = Assembly.GetExecutingAssembly(); var resourceName = "RateLimiter.Redis.sliding-window.lua"; using var stream = assembly.GetManifestResourceStream(resourceName); using var reader = new StreamReader(stream); _luaScript = reader.ReadToEnd(); The script is read once in the constructor. Cached as a string for the lifetime of the RedisRateLimiter instance. Zero file dependencies at runtime. Zero performance overhead after startup. The result: → Readable .lua file during development → Proper IDE support and syntax highlighting → Separate Git history for the script → Compiled into the assembly at build time → No loose files to manage at runtime → No file path issues across environments Embedded resources are one of the most underused patterns in .NET. When you have a file that's part of your logic — not configuration — embedding it in the assembly is the right call. Have you used embedded resources in your projects? What for? 👇 Part 7 of my rate limiter build series — follow for more. #dotnet #csharp #redis #dotnetdeveloper #backend #aspnetcore #softwaredevelopment

I’ve been spending a lot of time recently looking under the hood of Operating Systems—studying process states, concurrency, and thread scheduling. Instead of just reading about these concepts, I wanted to put the theory into practice by building a system that actually relies on them. I just finished engineering a fault-tolerant Distributed File System (DFS) from scratch using Java! 🚀 Instead of relying on heavy abstractions or frameworks like Spring Boot, I wanted to understand the raw mechanics of how enterprise storage systems (like HDFS or AWS S3) manage data, network traffic, and hardware failures. Here is what I built under the hood: ⚡ Custom TCP Protocol: Bypassed REST entirely for internal node communication, utilizing raw TCP Sockets for ultra-low latency binary streaming. 🧠 Concurrent Memory Safety: Designed the Master Node using a ConcurrentHashMap and thread pools to handle asynchronous web requests with constant-time lookups and zero memory corruption. 🔄 Auto-Recovery & Fault Tolerance: Engineered a replication algorithm (Factor of 3) with background Heartbeat daemons. If a Data Node OS process is terminated mid-operation, the Master instantly detects the failure and self-heals the download using backup replicas. 📊 Real-Time Visual Dashboard: Built a decoupled, asynchronous JavaScript/HTML/CSS frontend to map file chunks and monitor live node health. Building this forced me to navigate complex systems engineering challenges, from breaking network socket buffer deadlocks to managing disk I/O with Java NIO. It was an incredible way to bridge the gap between OS theory and real-world distributed architecture. If you want to see the code or run a "Chaos Monkey" test on the cluster yourself, check out the repository here: https://lnkd.in/gdsA2Hwm #SoftwareEngineering #Java #DistributedSystems #ComputerScience #Networking #WebDevelopment #BackendEngineering

Just shipped my most complex backend architecture yet! Meet FoodRush—a fully decoupled, event-driven food delivery platform. 🏎️💨 I built this project to put advanced system design patterns into practice. No central orchestrator, no monolithic database, and no synchronous bottlenecks during heavy loads. The Engineering Highlights: ⚡ Event-Driven Core: Handled distributed transactions and rollbacks using SAGA Choreography over Apache Kafka. ⚡ Isolated State: 5 independent microservices (Java 21 / Spring Boot 3), each with its own isolated MySQL database. ⚡ Real-Time Speed: Built live driver tracking and split-bill "Group Carts" using WebSockets (STOMP) and Redis Pub/Sub. ⚡ AI Integration: Context-aware meal suggestions powered by the Gemini API. Check out the architecture diagram below to see how it all connects! 🔗 Source code & deep-dive documentation: https://lnkd.in/dkHYrSbK #SoftwareEngineering #Kafka #DistributedSystems #JavaDeveloper #BackendEngineering #SystemArchitecture