Kevin Robayna

Dear Software Engineers, repeat after me: I will always do it:  – One fix at a time. – One bug at a time. – One lesson at a time. – One review at a time. – One deploy at a time. – One system at a time. – One refactor at a time. – One problem at a time. – One pull request at a time. Stop trying to build everything at once, that includes: — Context-switching till your head spins. — Jumping between 3-4 projects without finishing any. — Chasing new frameworks while your core app breaks. It feels fast. It looks busy. But months pass, and you’re stuck where you started, just with more meetings, more half-finished tasks, and way more stress. The speed you’re looking for always comes from focus, from doing one thing well, finishing it, and then moving to the next. Get ruthless about your focus. Decide what matters, what moves the needle, and say no to the rest (without guilt). Because at the end of the day, your code, your impact, and your sanity depend on it.

1,251

60 Comments

A common mistake I see: People treat message queues and streams as if they’re interchangeable. They’re not. Here’s the difference 👇 Message Queue (MQ) - Designed for delivery guarantees (at-least-once, exactly-once). - Great for sporadic workloads and asynchronous tasks. - Messages are consumed and removed. Once acknowledged, they’re gone. - Think: order processing, background jobs, retry logic. Stream - Designed for real-time, high-throughput, continuous data. - Data is append-only and replayable. - Multiple consumers can read the same stream independently. - Think: real-time analytics dashboards, fraud detection, monitoring pipelines. Why Streams fit Aaron’s case (real-time analytics for e-commerce): - Freshness matters → Streams process events as they arrive, with low latency. - Replayability matters → If a consumer goes down, it can re-read from the offset. - Scale matters → Streams partition data for massive parallel consumption. A message queue here would introduce unnecessary latency and discard historical events that analytics needs to stay accurate. Rule of thumb: - If you care about delivery → Message Queue. - If you care about freshness & scale → Stream. That’s why the right answer here is: Streams for real-time analytics.

963

68 Comments

JetBrains just announced they're moving to a single, unified IntelliJ distribution starting with version 2025.3. No more choosing between Community and Ultimate - it's one IDE with features unlocked by subscription. Why does this matter? • Some previously paid features (Spring support, database tools) are becoming FREE • The open-source commitment remains, but with a twist • This signals bigger changes in how dev tools compete in the AI era I spent time analyzing the announcement and its implications. This isn't just about IntelliJ - it's about the future of IDEs in a world where AI assistants are changing how we write code. Full analysis here → https://lnkd.in/gBpSNWUu Curious: How many of you are using IntelliJ Community Edition today? What's your take on this change?

162

4 Comments

🚀 Tired of waiting 15+ minutes for your Spring Boot tests to complete? Your slow test suite isn't just an inconvenience - it's killing your team's productivity and creating a culture where developers skip running tests locally. The hidden culprit? Misused Spring TestContext caching. In my latest article, I showcase how the Spring Test Profiler can help you: ⏲️ Identify which tests force expensive context recreations 📝 Get specific recommendations to maximize context reuse ⏱️ Achieve 50-80% faster test execution times 🧪 Transform test optimization from guesswork into data-driven decisions Real results: One project went from 18+ minutes to just 4 minutes (77% improvement) by optimizing context caching. The best part? It's completely open-source and works with Spring Boot 3.x + Java 17+. Fast tests enable fast development. Don't let slow tests be the bottleneck in your delivery pipeline. 📖 Read the full guide 👇🏻 https://lnkd.in/d-9NqCMu

48

Blogged: Converting an xUnit test project to TUnit https://lnkd.in/eRKYKwnX In this post I discuss the new TUnit testing framework, why I ported one of my libraries to use it instead of xUnit and related issues I had to deal with #dotnet #testing

64

Most engineers get stumped by high-level design in system design interviews. Often, they aren't even sure where to begin. Luckily, we've put together a tried and tested framework for easily building up to a working application. 1) Identify "what the system should do" 🔶 These are also known as the functional requirements 🔶 E.g. The users can make posts, like posts, follow other users etc 💡Think about what features you would want the system to have 2) Identify "how the system should behave" under specific constraints 🔶 What are the latency requirements? 🔶 How do we ensure our servers don't crash with an increasing number of users? 🔶 How do we ensure the system is always available when it's expected to be available? 🔶 How do we ensure fault tolerance to prevent data loss? 🔶 What are the trade-offs? Why should we choose one technique over the other? 3) Start addressing functional requirements in the most basic way possible 🔶 Map the data flow for each requirement with some services. E.g. When the client makes a post, they interact with a "Tweet Service" and that gets stored in a "Tweet DB" ❌ Do not add any complicated parts - this way the interviewer can correct you early on if you've made a mistake. 4) Think about how you can use your knowledge of the core system design components when addressing the functional requirements 🔶 If we have multiple services, it probably makes sense to use an API Gateway. Think of it, you wouldn't want to expose the services directly to clients. Instead, you want controlled access. 5) Once you have a feasible "what" down, address the non-functional requirements ❌ Biggest mistake candidates make here is to not tie the recommendations back to the original non-functional requirements they identified. Think about: 🔶 How you would choose between vertical scaling and horizontal scaling, and why? In our case, we can deploy more instances of the same service so we can handle requests in parallel. 🔶 Hmm... but how would you decide traffic is distributed evenly across all instances? Maybe we should consider a load balancer. 🔶 For latency, would the system benefit from caching? Is it necessary? 🔶 Think about edge cases when it comes to preventing data loss - would it make sense to have a buffer? 🔶 How do we safeguard against a database going down? A distributed database is designed to replicate and store data across multiple nodes in a cluster. High-level design should take 15-20 minutes, which is the bulk of the interview. This is then followed by a deep dive session, which lasts another 10-15 minutes. We will be covering how to ace your deep dive session in the upcoming posts. Stay tuned! --- Put this framework into practice today -> https://lnkd.in/ecQeq-s6

104

6 Comments

Tonight I will be joining a session with the Chrome DevTools team to talk about the network debugging experience in DevTools. Thanks Barry Pollard for connecting me 🙌 One of my own feedback points: 👉 It’s difficult to capture and share request + response details. When a network error happens, developers often need both the request info (URL, headers, params) and the response (body, status code) in one place. Right now, DevTools doesn’t have an easy one-click export or screenshot for this, which would be super useful for bug reports and troubleshooting. --- The team is also focusing on challenges developers face when debugging network issues end-to-end (from back-end to front-end), such as: - Working with / integrating between multiple disjointed systems - State management challenges that make it hard to reproduce bugs reliably - Difficulty understanding the payload of large requests, or dealing with 100s of network requests on a single page (noise, latency, etc.) - The complexity and limitations of end-to-end tracing across deeper back-end components or distributed systems - Difficulty reproducing real-world conditions (e.g. prod vs. dev, latency and bandwidth inconsistencies) - Not being able to inspect network activity due to security constraints 💬 If you’ve got your own pain points with the Network tab, please drop them in the comments and I’ll pass them along! Thanks for your input, everyone 💛

50

3 Comments

'We only hire senior developers' Congrats! You're building a time bomb. Here's why: Senior-only teams create: • Echo chambers of outdated practices • Zero knowledge transfer • Expensive solutions to simple problems • 10 architects, no builders What you're really missing: • Fresh perspectives • Hunger to learn • Questions that challenge assumptions • Future leaders The brutal truth: • Your 'senior' requirements are fear-based • Your '10 years experience' is arbitrary • Your 'no junior devs' policy is expensive technical debt Why this matters: • Innovation needs new eyes • Growth requires teaching • Sustainability demands succession • AI is leveling the experience gap anyway How to fix it: 1. Hire for potential, not just experience 2. Create mentorship structures 3. Balance your team pyramid 4. Accept that juniors today code better than seniors did 5 years ago Remember: Today's 'risky' junior is tomorrow's 'savior'. What's your take on the senior-only trend? Drop your thoughts below 👇 *** P.S. If your entire team is senior developers, who's asking the 'stupid' questions that prevent stupid mistakes?

93

23 Comments

95% of people think the highest-paid software engineers spend most of their time writing code. But if you watch them, you'll notice something else. Here's what top engineers actually do a lot: Read code and documents (more than they write) → Talk to other engineers and teams, asking questions, clarifying, and sharing context → Listen deeply, sometimes for long stretches, just to really understand → Spend hours thinking, mapping ideas, sketching on whiteboards, erasing, and starting over #code #development #growth

48

A Director of Engineering for a 100-person team told me their biggest bottleneck isn't CI/CD or code review. It's the staging environment. Director: "We have one staging environment. At any given time, 3-4 teams are trying to push their changes in for testing. It's constantly breaking, and we spend hours trying to figure out whose change caused the issue." Me: "So it's a race to merge, followed by a blame game?" Director: "Exactly. Devs get frustrated. QA gets blocked. We either delay releases or ship things with less confidence because we couldn't get a clean testing window." This is a classic scaling problem. The old model of a single, shared, long-lived staging environment creates a zero-sum game. The new model? Give every developer a personal, ephemeral "sandbox" for their feature within the shared environment. Instead of fighting for control of the environment, smart request routing isolates each developer's changes. Dev A can test their PR without ever being affected by Dev B's work, even though they share the same underlying infrastructure. The results we're seeing are profound: - Testing contention: Eliminated. - Environment-related release delays: Down 90%+. - Time spent debugging "who broke staging": Near zero. The Director’s follow-up was telling: "You mean my teams can test in parallel without stepping on each other's toes?" Yes. That’s the power of modern development infrastructure. How does your team manage the staging environment bottleneck? I'm keen to hear your strategies. #PlatformEngineering #StagingEnvironment #DeveloperExperience #CICD #Microservices #EngineeringLeadership #DevOps #Testing

414

353 Comments

Don't make the mistake of assuming that, because there's no formal code review (e.g., with a Pull Request) that code isn't being reviewed. It might be that code's actually being reviewed *continuously*, and with much more focus and rigour. For example, when I'm doing TDD, after I've passed the newest test and committed the code, I review the code I've added or changed. And I'm quite systematic about - readability, duplication (Rule of Three), complexity, coupling and cohesion, common code smells (long methods, large classes, divergent change, feature envy and so on. Then I run a linter on the changed files - they can do that, dontcha know? - to look for any low-level issues I might have missed; unused imports, fields that could be immutable, methods that could be private, etc etc. And if there are issues, I refactor. And after each refactoring, when my tests are passing, I review the code again in case my refactoring has made the code worse - e.g., harder to understand - and if it has, I might revert/undo and try something else. And you might be thinking, "Gee, that sounds like a lot of work to be doing 10, 20, 30 times an hour!" But here's the thing: we're talking about a few lines of code in each review. And many issues have already been picked up as that code was being written by my pairing partner. Indeed, quite a few issues are caught before the code's even been written by just talking about what we're gonna do next. Because when you've done a gazillion code reviews, and done them systematically, you basically turn into a human linter. So, no, I don't do formal code reviews. But my code *is* reviewed. A LOT.

55

10 Comments

𝘞𝘩𝘺 𝘠𝘖𝘜𝘙 Automation 𝘧𝘳𝘢𝘮𝘦𝘸𝘰𝘳𝘬 𝘸𝘪𝘭𝘭 𝘍𝘈𝘐𝘓 𝘪𝘯 6 𝘮𝘰𝘯𝘵𝘩𝘴 (𝘢𝘯𝘥 𝘩𝘰𝘸 𝘵𝘰 𝘧𝘪𝘹 𝘪𝘵) I just audited a $50M company's automation framework. Result? 73% of their tests were failing randomly. Their CTO asked me one question: "How did we go from 10 passing tests to complete chaos?" The Brutal Truth: 85% of Selenium Projects Die the Same Death Month 1: "Our automation is amazing!" Month 6: "Why does everything break when we deploy?" Here's what kills every framework (and the fix): 1️⃣ The "Everything in One Folder" Disaster ❌ Death pattern: UI, API, utils all mixed together ✅ Fix: Dedicated packages → UI, API, POJO, services separated Reality check: Good teams onboard new devs in 2 hours, not 2 weeks. 2️⃣ The "Hardcoded Hell" Problem ❌ Death pattern: URLs, data, timeouts scattered everywhere ✅ Fix: Environment property files + externalized test data Game changer: Switch DEV→QA→PROD with one command. 3️⃣ The "No POJO = No Scale" Trap ❌ Death pattern: Raw JSON strings, manual API payloads ✅ Fix: Request/Response POJOs + schema validation Impact: API tests become 10x more maintainable. 4️⃣ The "Debug Nightmare" Issue ❌ Death pattern: "Test failed" with zero context ✅ Fix: Extent Reports + screenshots + API logs Truth: Debug time drops from 2 hours → 5 minutes The Framework That Actually Scales I've built a production-ready structure that includes: 🏗️ Proper separation of UI/API/POJO layers 🔧 External configurations for all environments 📊 Rich reporting with screenshots & metrics 🚀 CI/CD ready with Docker & Jenkins support 🎯 BDD structure that business teams understand The Bottom Line: Stop building "quick automation scripts." Start building software systems that scale. Your framework should work at test #10 AND test #1000. Want the complete folder structure? 👇 Comment "𝑭𝑹𝑨𝑴𝑬𝑾𝑶𝑹𝑲" and I'll send it to your inbox! Found this helpful? Share with someone struggling with flaky tests! 🚀 -x-x- Full Stack QA & Automation Framework Course with Clearing SDET Coding Rounds: https://lnkd.in/g7tn6Uif #japneetsachdeva

157

10 Comments

So, you want to be a Mobile Platform Engineer? In my previous article, I covered what a Mobile Platform Engineer does. This follow-up article covers the practical steps to actually get there. What I cover: - How to adjust your work so you deliver features AND help your entire team - How to position yourself with existing platform teams (hint: become their ally) - How to become the first Platform Engineer at companies that don't have platform teams yet - And more! The full guide includes positioning strategies, common mistakes that backfire, realistic timelines, and what success actually looks like.

107

3 Comments

Software Architecture Documentation Good architecture is as much about communication as it is about code. A well-documented architecture bridges the gap between vision and implementation, aligning teams and ensuring longevity for your systems. Software architecture docs are the blueprint for understanding, talking about, and changing a system’s design. It helps teams work together better by keeping track of important decisions and details. Good docs make it easier to scale, debug, and improve the system, plus everyone understands what’s going on. Keep your docs short, useful, and organized (like using ADRs, RFCs, etc.). Think of them as code—always updating. Here are a few ways of writing and managing one: 1️⃣ Architecture Decision Records (ADRs) Every choice in architecture has consequences—technical, operational, and cultural. ADRs provide a lightweight, structured way to document why decisions were made, the trade-offs considered, and the context at the time. They’re invaluable for future teams to understand the why behind the how. 2️⃣ Request for Comments (RFCs) Collaboration is key for a sound architecture. RFCs enable open dialogue by inviting feedback on proposed changes before implementation. They create a culture of shared ownership, making the architecture a living, evolving entity rather than a rigid blueprint. 3️⃣ Event Storming When designing complex systems, especially those using event-driven architectures, event storming helps. By focusing on business events, you uncover hidden domain knowledge, identify bottlenecks, and align stakeholders—technical and non-technical alike. 4️⃣ The C4 Model Clarity is king. The C4 model—Context, Containers, Components, and Code—provides a zoom-in/zoom-out approach to documentation that scales with your audience. Whether you’re talking to a developer or a CEO, the C4 model ensures they see what they need to see. To summarize Architecture documentation is significantly more than mere paperwork; it serves as the crucial bedrock upon which resilient, scalable, reliable and maintainable systems are built and sustained. The proper execution of this process will significantly enhance your team’s ability to work at an accelerated pace, all while ensuring the maintenance of high standards and minimizing the potential for errors. What are your go-to techniques for documenting architecture? #SoftwareArchitecture #Documentation #ADRs #RFCs #EventStorming #C4Model

81

15 Comments

In 5 years, APIs won’t be the core software deliverable For decades, we shipped functionality, wrapped in endpoints. That era’s ending. As agentic architectures mature, the dev’s job changes: - You won’t build APIs. - You’ll assign tasks to agents. You don’t expose endpoints anymore. You expose outcomes. This breaks everything we spent years mastering: - REST patterns. GraphQL schemas. SDK wrappers. - All optimized for humans who needed to know how things worked But agents don’t care how. They just need the goal. Code isn’t going anywhere. But the interface moves up. From logic to intent. From endpoints to tasks. From API design to outcome design. It’s uncomfortable. But the teams who embrace this shift? They’ll define the next era of software, before everyone else catches up.

142

120 Comments