Matt Syp

PSA: If you remove or deprecate a feature, give your engineering team the time to fully remove that feature from your codebase. Your future self (and your future team) will probably not remember to thank you, but their higher velocity might be a thank you enough. Every line of code in production comes with a cost, however hidden it may be in the present moment. End of message.

16

5 Comments

“Why are we using a rocket launcher to butter toast?” you might ask... What happens when a perfectly sensible architectural decision quietly drifts out of alignment with reality. A SaaS search engine built for full-text search and clever relevance scoring… being used for glorified key-value lookups. Seventy-five million requests a month. Lots of cost. No edge caching. Limited observability. Ouch. The real lesson here isn’t just “this technology is faster and cheaper” (although 35ms P50 latency and a 0.0001% error rate are nothing to sniff at). It’s about architectural honesty. Stripping a system back to what it needs. Using organisational learning instead of reinventing the wheel. Designing observability in from day one. And migrating gradually, with dual-running and rollback paths, so 75 million monthly requests don’t even blink. 📣 Sometimes the strategic move isn’t adding something new. It’s removing the unnecessary. We’re back to our technical roots this week with a tale from Nick Theodoulou about re-architecting for simplicity https://lnkd.in/eGh_4fU5

17

9 Comments

a common pitfall in payment systems is not handling rounding correctly. you must ensure that all components of a payment collection are duly accounted for. things like taxes, fees, etc. this is often specified in percentages. if you would charge 1% of $123.45 in fees and 7.5% of the resulting value in VAT, you can see how this becomes a real problem. if your payment works across multiple markets, the problem gets more interesting. you may have different pricing and the taxes may be different. one thing I learned recently is that even the rounding laws for taxes may be different. for example, some countries like the US may require you to round to the nearest whole unit of the currency (a dollar in the US, vs cents). Malaysia requires you to round to the nearest 5 sen (a cent). the UK allows you to round income down to the nearest pound and round expenses up to the nearest pound. this means that rounding is something that requires context of the transaction such as the nature of the transaction and the applicable regulations. a generic rounding function will fail. but it gets even more interesting, after computing individual parts and rounding correctly, you must ensure that it all sums up to the correct amount. this means you can't round parts in isolation. a flexible part must exist to ensure the total balances up. otherwise, you may end up 'creating' new money or 'dropping' existing money in your system.

48

This is a really interesting article about writing agents with the Claude Agent SDK. It gets into design advice that you should consider when writing an agent with Claude. It chimes with what I’ve read about the development of Claude Code (write as little business logic as possible and concentrate on getting out of the way of the model). The general takeaway for me is from the three-block flow chart in the middle: Give the agent good tools/affordances in three categories: Gather Context, Take Action, Verify work. Do that at the right granularity, with good feedback, and then let the model do the driving. It’s deceptively simple, but it has a goldilocks quality to it. Trying to make a more complex flow chart with many more boxes and lines constrains the AI to just the things you could think of in advance and makes it overfit to what you know today. Trying to make it simpler by, for example, giving the agent a whole existing API as a single tool can overwhelm it with too much choice and then too much context in the responses. It’s definitely worth reading if you're interested in building or using agents, irrespective of AI vendor. https://lnkd.in/eKF2rXWb

7

Specs don’t fail because they’re written poorly — they fail because they can’t keep up. Requirements change, business shifts, UX evolves, dev discovers edge cases… and the spec stops reflecting reality. Teams end up working off different versions of truth. Pillir Studio eliminates stale specs by generating and updating them continuously, in sync with wireframes, logic, and test cases. Your spec becomes a living system, not a frozen document. https://lnkd.in/gnquEr7D

10

📣 The 7 AI KPIs every engineering leaders should track is here! Now you can quickly understand how your AI initiatives are performing, where they need improvement, and what next steps are necessary to drive progress. Metrics are broken down by: - KPIs for adoption - KPIs for productivity - KPIs for outcomes (There's even a section on vanity metrics!) Download it now and start making sense of how AI is impacting your organization: https://lnkd.in/gr__FSKe

48

3 reasons why we build software and service as one team: We don’t build tech *for* operations at Tandem. We build tech *with* operations. Here’s why that matters; 1) Fix friction at the root. If a vet has to click 5 times to do something that should take one, we fix it. Not just because it’s “inefficient”. But because it creates cognitive load, slows care delivery, and compounds under pressure. Less friction = faster throughput, fewer errors, and lower burnout. 2) Close the loop between builders and users. The person who writes the feature talks directly to the person who uses it. That means issues surface faster, fixes are more accurate, and nobody ships something that “technically works” but operationally fails. It’s not just “faster iteration” - it’s tighter alignment with reality. 3) Scale the system, not the sprawl. New clinics, new roles, new workflows. We don’t layer on SaaS duct tape. We evolve a system designed to flex with operational growth. That means fewer integration points, tighter control, and a consistent experience from core to edge. We don’t treat tech like a layer. We treat it like a nervous system. Because when you’re delivering care in the real world, you can’t afford delay, dissonance, or dropped signals. That’s why we built Tandem the way we did: One system. One team. Zero silos. Because when service and software evolve together, the whole organism gets smarter, faster, and stronger over time. ------------- Hi, I’m Doug. I’m the Chief Technology Officer at Tandem. We’re engineering the backbone for modern pet care. Follow me for posts on: * How we build tech with ops, not for them * How we build tech tools that scale cleanly * Scaling hybrid companies without SaaS bloat

27

2 Comments

📉 There’s a hidden tax in every integration project: poor documentation. Integration teams waste countless hours chasing tribal knowledge, reverse-engineering systems, or working from outdated docs. The result? Slower delivery, more errors, and a drag on business outcomes. In our latest blog, Aaron Kesler unpacks how AI agents are changing the game 🤖 automating documentation, surfacing real-time context, and freeing teams to focus on what really matters: building and delivering value. Read how AI is solving the documentation problem here 👉 https://lnkd.in/exmsG_tG   #AI #DataIntegration #AgenticAI

28

Drupal just got easier to work with — without losing what makes it powerful. 🧩 Canvas 1.0 introduces a component-based visual builder that balances layout control with developer flexibility. It’s not a shortcut—it’s a smarter path. In this week’s editor’s pick, Kazima Abbas highlights: • What Canvas means for editors and devs • Reactions from leaders like Aaron McHale and Jillian Chueka • How it fits Drupal’s low-code ambitions Read the full breakdown + other key ecosystem updates: https://lnkd.in/gVHfK6gG #Drupal #OpenSource #WebDev #LowCode

15

A little advice: don't vibe code fintech apps. Don't vibe code health tech apps. The nuances are many and critical. Be sure you know what you are doing with these two. Lighter Note: If the client's budget is 500k, you can vibe code it! Whatever happens, happens!

73

16 Comments

I've watched more projects fail from silence than from mistakes. The pattern is always the same: → Sales promises a feature next month. → Engineering schedules it for Q4. → The client loses it on launch day. No one lied. No one messed up. They just assumed everyone was on the same page. “Obvious” info lives in silos: → Sales doesn't know what's technically feasible → Engineering doesn't know what sales promised → The client didn't read your update email (most of the times) The fix isn't better documentation. It's brutal over-communication. Repeat yourself. In Slack. In meetings. In follow-up emails. Say it until it feels annoying. Because misalignment always feels worse. Assumptions kill. Communication saves. How do you handle this?

23

If you’re planning to modernize a legacy system that's been running for years and still manages a high volume of client traffic, the strangler fig pattern might be something that can help. Read Martin Fowler's blog post about the Strangler Fig pattern application. https://lnkd.in/gxKMuQ5G https://lnkd.in/gMxK3KUS If you’ve walked this path, what tipped your decision one way or another? #modernization #StranglerFig #SRE #softwarearchitecture #engineeringmanagement

40