Rhys C.

Here's another one from the "Code vs Environment" series: I got pulled into a 2 AM incident once, where the customer wasn't seeing any data on the front-end screen. The Cron job that loads nightly data into MongoDB had run just fine, and there hadn't been any recent code changes in production. Still, the APIs were returning zero records. After digging in, we found the issue: the system clock on the Mongo read replica had drifted away from the write node's clock. This likely happened after a recent maintenance task where NTP sync wasn't set up properly. The Cron job was inserting documents using the Write node system's local time, while the API queries were using the server's current time to fetch data. Because of the time mismatch, the newly inserted data wasn't showing up in the Query response. Lesson learned: your code can be perfectly fine, but things can still break if the environment isn't behaving the way it should. No bugs, no bad deploys - just a mis-configured server time that caused the whole issue.

14

1 Comment

To deal with complexity, the solution must be simple. Constantly surprises me how many companies think that piling on more complexity is the answer. Adding complex processes on top of complex problems is pouring petrol over a raging fire. What does this look like in practice? One example of tackling complexity with simplicity is Datastar. It's a 10kb script that replaces entire frontend frameworks like React, Vue and Svelte. It requires thinking and building differently, but the back end drives the page. Just like the good old days. Difference with the good old days is that we can develop reactive apps with it. Because Datastar allows the browser to do what it's good at, the solution is blisteringly fast, whilst being simpler. Caveat: I've not used it for any large projects yet, but on a smaller project it was a breath of fresh air. Link in the comments.

7

3 Comments

A little late in posting this, but I wanted to shout out the Brisbane JVM meetup I went to last week. It's been a while since I last got to a Java meetup, but this one had five great talks. Mark Perry on how AI makes Functional Programming easy. Neil Mason showed us how to keep your codebase clean by convention testing with Spring Modulith. Peter Becker is doing a lot of good things writing Playwright tests with Kotlin. Jobin Varghese talked about Data Oriented Programming in Modern Java. and lastly, Steven Doolan did a great talk on using Rod Johnson's Embabel to write code for Sam Aaron's SonicPi. A talk inspired by a conversation at last year's YOW! Conferences If you're a Java dev in Brisbane and haven't been to a Brisbane JVM, then you should talk to Rafael Villar Villar, Mark Perry, or Neil Mason, or go find BrisJVM on Meetup.

44

2 Comments

Myth: “If my tech team isn’t complaining, everything must be fine.” Silence can feel reassuring. If engineers aren’t raising alarms, surely the foundations are solid? Not necessarily. Good engineers are problem solvers. They work around issues. They patch. They optimise. They adapt. That’s what makes them effective. But quiet workarounds don’t remove strategic risk, they often conceal it. What doesn’t always get surfaced at leadership level is: • Architectural compromise that hardens over time • Scaling constraints that only show up under pressure • Increasingly fragile integrations • Growing complexity Not because the team is hiding anything. But because no one has asked, “What are we tolerating now that will cost us later?” Technical risk rarely announces itself loudly. By the time it surfaces, flexibility is lower and change is more expensive. That’s the leadership gap. CTO leadership is not about reacting to complaints. It’s about surfacing trade-offs at leadership level before they harden into constraints. Silence is not the same as safety. What isn’t being surfaced in your current discussions?

11

Coding agents can't fix what they can't perceive. This will lead to frustration if you don't recognise or fix it. At the moment I'm working on an agent 'assembly line': intentionally a subcomponent of a full-on software factory. You define a series of prompts, in order, that you definitely want to be run after every commit. The intention is to catch 'awareness gaps' like missing tests, dead code, duplicated code, and so on. These show up in your Claude Code statusline, so you can see if they're progressing. If any of the downstream agents commit, at the end of the chain the statusline updates to tell you to run a provided rebase skill, so you can get those into your working branch. This is hard for Claude Code to do full-on integration tests for, because Claude Code would need to look at another Claude Code, interactively, parsing its STDOUT, all while a long-running non-deterministic process happens. Hence it's a feature that I keep getting regressions in. The options are: • Try and find some sort of harness that lets me drive the Claude Code UI through Claude Code or tests • Have a test that just checks the statusline output, but does it temporally - polling it repeatedly while a chain executes, to check that it really does show the right things. • Rely on more mocking, which to be honest sounds a bit too low-level for 2026. The main lesson here is that if you get frustrated with things breaking when your agent thinks that they work, you need to give it the ability to perceive that failure. It can't fix what it can't perceive.

9

3 Comments

Is .NET still relevant in 2026? Short answer: absolutely. Despite the industry’s constant “flavor of the month” frameworks, .NET continues to dominate enterprise technology and it’s not slowing down. What stands out to me as a recruiter in the Software Engineering space: 🚀 Performance: ASP.NET Core consistently ranks among the fastest web frameworks 🌍 Cross-platform: One codebase across Windows, Linux, and macOS ☁️ Cloud-native & AI-ready: Strong alignment with Azure, microservices, and AI/ML use cases 🏢 Enterprise trust: Many global organizations still run mission-critical systems on .NET With ongoing innovation (including .NET 9 and 10), Microsoft has made it clear that .NET isn’t legacy, it’s strategic. From a hiring standpoint, this explains why experienced .NET developers remain in high demand across cloud, AI, modernization and enterprise transformation projects. If you’re a .NET engineer thinking about your next move or a business investing in future-proof tech, this is a space worth paying attention to. Excellent article on the above here: https://lnkd.in/dAHQGG-D #TechRecruitment #SoftwareEngineering #EnterpriseTech #HiringTrends #CloudDevelopment #AIEngineering

9

Does Vibe Coding really work for enterprise-level production code? Short answer - yes. But only if you treat it like engineering, not magic. We’ve been testing this across client builds. And the speed-to-production difference is insane. Non-technical teams now design entire flows in Lovable or Bolt.new. It’s not “playground prototyping” anymore, it’s structured context. Engineers pick that up in Cursor or Claude Code, refactor properly, run tests, and deploy clean. No 10-page docs. No handoff hell. No “wait till Monday’s sync.” Just fast, visual collaboration that actually scales. Even enterprise setups can handle it, we run custom branches on Netlify, separate logic with Node.js functions, and ship changes safely without touching the core stack. The trick isn’t the tool. It’s the workflow. Define stack → feed right context → review like a human. That’s it. Vibe Coding isn’t about replacing developers. It’s about removing miscommunication. And when that happens, small teams start shipping like big ones. If you’re building an MVP or scaling your stack and need a fractional CTO to set it up right, My DMs are open.

9

🚀 Just discovered Google's Gemini Code Assist and I'm genuinely impressed by what they're offering the developer community. What caught my attention: They're providing a completely FREE tier for individual developers with no credit card required. We're talking 6,000 code completions and 240 chat requests daily - that's serious usage for most developers. The standout features that have me excited: • **Gemini CLI** - AI assistance directly in your terminal (this is a game-changer) • **Agent Mode** - Performs complex development tasks across multiple files • **1M token context window** - Actually understands your entire project • **Multi-IDE support** - Works with VSCode, IntelliJ, PyCharm, and more But here's what really impresses me: they're not just doing code completion. The GitHub integration automatically reviews PRs for bugs and style issues, and the Firebase integration gives you AI assistance across your entire development workflow. For teams, the Standard ($19/month) and Enterprise ($45/month) tiers add enterprise-grade security and can connect to private repos for even more customized responses. I've been testing it in my current project and the code suggestions are surprisingly contextual. It's not just autocomplete - it actually understands what I'm trying to build. Anyone else trying this out? Would love to hear your experiences, especially with the CLI features. #SoftwareDevelopment #AI #GoogleCloud #DeveloperTools #Coding

8

3 Comments

I have always pondered this question - why do business leaders and project sponsors have a different standard for software development compared to other industries and circumstances? People - does anyone expect a coach of a Division 5 side with a division 5 budget to be competitive in the Permier League? Process - do Property developers do a complete rework of the requirements after the 20 storey, 400 apartment high is 50% complete? Technology - does an F1 team compete with an engine of a Toyota Camry? Quality - Are doctors, lawyers, psychologists, teachers, civil engineers etc all self taught? Budget - does a commercial tenant like woollies expect the landlord to provide support staff for free to help round up lost trolleys, bake bread, cut up the meats and stock the shelves? But yet all the equivalent scenarios are prevalent in the software industry. #softwaredevelopment #lifeofadeveloper #hardlessons #learntosayno #software #tech

5

4 Comments

I'm starting to put down my thoughts on why we recommend multi-instance root modules. As part of that, I'm thinking through the idea of what one of our decent sized client infra monorepos would look like if we ran it as single-instance. It doesn't look great... Here is the background info about this multi-instance infra monorepo that we built for this client: - 79 Root Modules (e.g. aws-backup, aurora-postgres, github-repositories, vpc, etc.) - Across those root modules we have ~54K lines of TF code (LOC), split across 691 OpenTofu files. - We have *238 instances* of these root modules. Each of these instances is a workspace for a given root module, and this is what makes this project "multi-instance". - Our average LOC per root module is ~684 (54,000 / 79) Now, if we ran this project with single-instance root modules, here is the back of napkin math on what that would look like: - If we implemented the single-instance pattern very naively (we've seen this mistake a lot of times), we'd have 238 root module directories and with our 684 LOC average we'd end up with roughly a whopping **163K LOC**. That 3X's the amount of code that we'd need to maintain. - If we implemented single-instance in the smart way, we'd still need the original 79 root modules (now child modules) and their corresponding ~54K LOC, BUT we'd add an additional 238 root module directories (one for for each instance) and some additional code to instantiate each. Say that code is roughly 100 LOC per root module, we'd add an additional ~24K LOC. In the latter case, things aren't that bad, right? At first glance, it seems fine. Just an extra bunch of directories and 24K LOC of code? What's 24K LOC between friends right? No big deal... except you don't have anything to enforce that each instance is *only* a call to a child module ☠️ Oh damn, somebody needs a resource quick? Oops, they added it to the root module directly and now dev is not like stage or prod. Eh, I'm sure the team will figure it out on the fly. 💣 Yeah... safe to say, we don't like to use the single-instance root module pattern. Can it be done well? Sure, but it opens you up to the hard left hook of "bad practices are easy". You mind as well just shoot yourself in the foot at the start instead of waiting for that new team member to do it to you. Alright, bring on the pitch forks in the comments, I can take it 😘 #terraform #opentofu #infrastructure #infrastructureascode #iac #platform #platformengineering #platforms #cloud #devops

19

17 Comments

In this presentation, Colin cogently articulates the rationale for choosing Components over Containers and why Agentic Systems provide a catalyst for that paradigm shift (especially from around the 19 minute mark).

2

There’s a point most growing engineering teams hit where adding people stops translating into more output. Delivery slows down even though the team is larger, more experienced, and better staffed than before. On paper, everything should be moving faster. What actually increases is the amount of coordination required to get anything done. Work that used to move within a single team now crosses multiple teams. Decisions take longer because more people are involved. Changes that used to be straightforward start depending on other systems, other priorities, and other timelines. You begin to see delays that aren’t tied to effort, but to waiting. Waiting for alignment, for approvals, for dependencies to clear. At that stage, the issue isn’t whether the team is capable. It’s whether the way work is structured still makes sense for the size and complexity you’ve reached. In many cases, it doesn’t. Ownership becomes diffuse. Teams rely on each other for too many pieces of the same outcome. Progress starts to require coordination by default, instead of exception. And that’s when growth starts working against you. The teams that handle this transition well don’t just keep hiring. They rethink how work is divided, how ownership is defined, and how much independence each team actually has. Because beyond a certain point, adding capacity without adjusting structure just creates more friction around the work, not more progress through it.

3

clay changed their entire pricing model today. not a tweak. a restructure. here's my honest take on who this helps and who it hurts. I've been building in Clay daily for over a year. tables, Claygents, HTTP API integrations, enrichment architectures. I'm not a partner. I'm not an affiliate. nobody pays me to say nice things about Clay. breakdown. ✅ CRM sync dropped from $800/mo (Pro) to $495/mo (Growth). if you were paying $800 just to push data to HubSpot or Salesforce, that's $3,660/year back in your pocket. ✅ data costs cut 50-90% across top enrichments. if you run high-volume enrichment, your unit economics just improved significantly. ✅ Web Intent signals and Clay Ads bundled into the Growth plan. features that used to be enterprise-only. ⚠️ HTTP API moved UP from $349 Explorer to $495 Growth. and HTTP calls now consume Actions. if you built your stack on HTTP columns at the Explorer tier, this hits twice. higher plan cost + a new consumption meter. ⚠️ entry price went from $149 to $185. plus you now have two currencies to track (Data Credits + Actions) instead of one. more to learn before you can evaluate whether the tool works for you. ⚠️ light users paying for capacity they'll never touch. 15,000 Actions/mo on the Launch plan when you only run 2,000 enrichments. the real move here: Clay is becoming a platform, not a data tool. cheaper data is the incentive to go deeper. Actions are the new monetization layer. that's not bad. but it means the pricing works best for builders who use Clay as infrastructure. if you're only doing light enrichment with no CRM sync or API work, run the numbers. you might be paying platform tax for orchestration you don't use. existing customers are grandfathered. no forced migration. but you have until April 10 to switch between legacy plans (one-time window). after that, legacy tiers close. full breakdown with side-by-side tier comparison, migration decision framework, and who-wins-who-loses analysis on the blog 👇 shawn ⚡ GTM Engineer

22

24 Comments

Hey boss, we’re going to need more budget for red yarn. 🧶 Your developers shouldn’t be spending valuable development time chasing down the steps to reproduce bugs. Clear, concise, reproducible test plans and bug reports go a long, long way.

9

4 Comments

This feels like a pretty profound change in how I debug applications. I'm not looking at traces in Logfire, I'm just asking Claude to work out what's going wrong by querying Logfire, then fix it. If you're using an O11y platform that can't be easily viewed by your coding agent (e.g. doesn't have a SQL interface), you're betting against the model - it's that simple. Pydantic Logfire is the one true AI observability platform.

199

12 Comments

After 20+ years building backend systems, I’ve become increasingly cautious of frameworks that hide execution behaviour. One of the most dangerous lines of code in a backend system can look completely harmless: order.getLineItems() Depending on the persistence framework, that single line might load thousands of rows from the database without the developer realising it. Over time I’ve come to prefer architectures where: • database access is explicit • service interactions are predictable • side effects are visible in the code In other words: Boilerplate is cheap. Unpredictability is expensive. I wrote a short article about the principles that now guide how I design persistence layers and microservice architectures. Medium link below 👇 https://lnkd.in/gEweiykc #softwarearchitecture #backendengineering #microservices #softwareengineering

27

1 Comment

Engineering and AI. I've seen so many posts about this recently on LinkedIn... it seems to be a hot topic for so many companies who develop software at the moment, and understandably so. Having led engineering teams through this transition it's a topic I know very well. I've seen posts from engineers who fear that employers are being taken in by the huge cost saving measures without understanding that engineers are still required to use the AI tooling... I've also seen posts from directors who want to save costs by using these tools to help their teams develop faster and more efficiently. Having implemented AI tooling with my engineering teams I can say first hand both types of view are somewhat right. You do need engineers to implement and run AI tools and you can gain a much higher ROI on developer cost by using them. However you have to do it in the right way. As an engineer you need to learn the tooling - as with any new tool - and use it to its full capability. Asking it to plan out how it is going to code something, working with it to tweak its plan based on your knowledge and mitigate any hallucinations is a key step. You need good system knowledge to do this and core knowledge of engineering principles around security, scalability and design patterns you want to use. The engineer changes from 'writing code' to 'design and describe' alongside being a gatekeeper. The review stage is important too, you need to understand what has been written, not just check it works. As a business owner you absolutely can save money compared to writing code by hand or even compared to engineers utilising AI tools at a basic level (autoprompt etc...), to do this you need to support your engineers in adopting and learning this new tech alongside integrating it properly into your development pipelines. The swarm approach is of course the dream, multiple agentic AI models working together to understand problems and user statements, design changes, develop, test and deploy them. Even amending problems or blockers in their own pipelines. I think we will get there in the future... although it's a way off yet. Even then we'll need the right people to set strategy and direction. A tool as always is only as good as the information it is given. There is a reason these AI tools are called LLMs (large language models) - they read a huge amount of information and then act based upon it. That information needs to come from somewhere and be moderated by someone when it is wrong or undesired. If you're a business navigating this and want to speak to someone who's implemented this at scale feel free to reach out. I'm happy to share tips and guidance. What have your experiences in this area been so far?

20

5 Comments

One of the biggest growth points I see in early-career engineers is learning to live with uncertainty. They want the complete roadmap. Every variable accounted for. A guarantee before they take the first step. But in engineering (and in life), the perfect plan simply doesn't exist. Instead of chasing certainty, I encourage my team to aim for direction and clarity. Sometimes you’re not steering a speedboat; you’re piloting a sailboat. You set a course roughly in the right direction, then adjust your sails as you learn from the journey. The world is too complex for certainty. The teams that wait for perfect data stay stuck analyzing. The teams that act, learn, and iterate? Those are the ones solving real problems for customers. If you're feeling paralyzed by incomplete information, remember: The goal isn’t to eliminate uncertainty. The goal is to build confidence in your ability to navigate.

25

14 Comments

Too many teams are still chasing DevOps unicorns. The truth? Retention comes from clear roles, growth paths, and building environments where good engineers can become great. Here’s how smart companies are fixing it... 

2