The Software Engineering Podcast with Fexingo: Code, Architecture, and Engineering Best Practices

In this episode, Lucas and Luna explore how a single engineer at a mid-sized SaaS company cut Kubernetes costs by 40 percent—without sacrificing performance. They dive into the specifics of right-sizing requests and limits, the role of the Vertical Pod Autoscaler, and how a simple resource optimization culture shift made it stick. Using a real-world case, they break down the process: analyzing uti...

In this episode, Lucas and Luna unpack a specific case from a mid-sized SaaS team that slashed their continuous integration wait times by 90 percent. The trick wasn't buying faster runners or rewriting tests. It was rethinking how Docker builds are cached, specifically using BuildKit's cache mounts and remote caching. We walk through the before-and-after numbers, the key configuration changes, and...

In Episode 166 of The Software Engineering Podcast, Lucas and Luna dive into a real-world case where a mid-sized SaaS company slashed its database spend by 40 percent without sacrificing performance. They walk through the technical decisions behind data tiering—moving cold data to cheaper storage, using partitioning, and leveraging PostgreSQL's declarative partitioning. The hosts break down the tr...

In this episode, Lucas and Luna explore how a fintech team slashed GraphQL response times by 60 percent using persisted queries and a smarter caching layer. They break down the difference between standard query hashing and true persisted queries, walk through a concrete example of a mobile app that went from 400 milliseconds to 160 milliseconds on a 4G connection, and discuss the trade-offs around...

In this episode, Lucas and Luna dig into how a fintech startup slashed its continuous integration bill by 70 percent by replacing a permanent staging environment with ephemeral, on-demand preview environments. They walk through the architecture: a Kubernetes cluster that spins up a full stack per pull request, tears it down after merge, and uses Terraform to manage the lifecycle. The hosts break d...

In this episode, we dive into the story of a single engineer at a mid-sized fintech who used AWS Lambda SnapStart to cut cold start latency from 2.4 seconds to under 300 milliseconds. We break down what SnapStart actually does—taking a snapshot of the initialized execution environment and resuming from it—and why it matters for serverless Java workloads. We also discuss the trade-offs: the snapsho...

In this episode, Lucas and Luna dig into a story that sounds almost too good to be true: one carefully designed Postgres index cut a query's runtime from 12 seconds to under half a second — a 95 percent improvement. They break down what the index actually was, why it worked so well, and the trade-offs the engineer had to weigh, like storage overhead and write performance. Along the way, they discu...

In this episode, we dive into a real-world case where a team at a mid-sized SaaS company slashed its AWS bill by 60 percent—not by rearchitecting everything, but by strategically using reserved instances and savings plans. We break down how they analyzed their usage patterns, committed to the right mix of payment options, and avoided common pitfalls like overcommitting. We also explore the broader...

In this episode of The Software Engineering Podcast, Lucas and Luna revisit the challenge of slow builds. They focus on a specific case: a mid-sized fintech company whose monolithic Maven build took almost forty minutes. After switching to Bazel, the same build dropped to under twelve minutes. They break down why Bazel wins on caching, parallelism, and remote execution, and they explain the real c...

In this episode of The Software Engineering Podcast, Lucas and Luna dive into the story of a team that shaved 80 percent off their Docker image sizes by moving to a distroless base image and multi-stage builds. They break down the concrete steps: switching from a full Ubuntu base to a minimal runtime, using build stages to strip out compilers and dev dependencies, and scanning the final image for...

In Episode 158 of The Software Engineering Podcast, Lucas and Luna dive into a specific success story: how a mid-sized fintech team reduced their GraphQL API latency by 60 percent. They break down the root causes — from N+1 queries to inefficient resolvers — and walk through the practical fixes: DataLoader batching, query depth limiting, and strategic caching. Expect concrete numbers, real trade-o...

In this episode, Lucas and Luna dig into the story behind a major e-commerce platform's near-fatal deployment that led to a 50 percent reduction in rollback disasters. They explore how a small team of engineers used feature flags to segment deployments, canary releases, and kill switches, transforming their incident response. The conversation covers the technical and cultural shifts required, from...

In this episode, Lucas and Luna dive into a real-world case where a team at a mid-sized fintech company slashed their Kafka storage costs by 90 percent using tiered storage. They break down how the engineer moved older data to cheaper object storage while keeping it available for replay, the trade-offs in latency and durability, and the one metric that made all the difference. If you've ever wonde...

In episode 155 of The Software Engineering Podcast, Lucas and Luna dive into the story of a fintech team whose feature-flag strategy turned a potentially catastrophic release into a fifteen-minute fix. They break down how a well-structured kill switch, combined with gradual rollouts and observability, reduced rollback time by 95 percent and cut incident duration in half. The conversation covers pr...

In this episode of The Software Engineering Podcast, Lucas and Luna talk with Alex Reyes, a senior engineer who cut his company's cloud infrastructure bill by 60 percent. The trick wasn't switching providers or buying reserved instances — it was a radical rethink of how they stored and accessed data. Alex shares how he started by profiling storage access patterns, found that most data was rarely r...

In Episode 153 of The Software Engineering Podcast, Lucas and Luna explore how a single engineer at a mid-sized fintech company slashed their monorepo build times by 60 percent by migrating from Maven to Bazel. They break down the migration strategy, the challenges of incremental adoption, and the surprising side effects: faster CI, happier developers, and a 30 percent reduction in cloud compute c...

In this episode of The Software Engineering Podcast, Lucas and Luna explore a real-world performance puzzle: a routine analytics query that was silently consuming 60 percent of a Postgres database's CPU. They walk through how one engineer traced the problem not to indexing or hardware, but to a subtle interaction between a join condition and a function wrapper that defeated the optimizer. The conv...

When a team at a major fintech saw their Kafka consumers constantly rebalancing, every message-processing pipeline stalled. In this episode, Lucas and Luna dig into the specific story of one engineer who diagnosed the root cause of a rebalance storm that was crippling production for weeks. They explain what consumer group rebalancing actually is, why it happens, and the three concrete fixes that b...

In this episode, Lucas and Luna dig into a real-world case where a team slashed their serverless bill by 80 percent just by switching from Node.js to Go. They explore why the language choice matters more than you might think in a serverless world, how cold starts and memory allocation drive costs, and the trade-offs between developer velocity and runtime efficiency. You'll learn the concrete facto...

In this episode, we break down how a single engineer at a mid-sized fintech cut Redis memory usage by 70 percent—and slashed their cloud bill by $180,000 a year—by switching from a naive key-per-user design to a more compact hash-based structure. We explore the trade-offs of using Redis hashes over plain strings, the math behind the savings, and the hidden costs like CPU and operational complexity...

In this episode of The Software Engineering Podcast, Lucas and Luna dive into how one engineer slashed AWS Lambda cold-start latency by over 70 percent using AWS Lambda SnapStart. They explore the mechanics behind snapshotting and restoring execution environments, the trade-offs with in-memory state and one-time initializations, and how the engineer applied it to a Node.js service serving real-tim...

Lucas and Luna dig into a specific case where one engineer cut query time from 800 milliseconds to 40 milliseconds by rebuilding a Postgres index strategy. They walk through the before-and-after, the trade-offs of covering indexes versus partial indexes, and why understanding your read patterns matters more than any indexing shortcut. The episode also touches on the human side: how the engineer co...

In this episode of The Software Engineering Podcast, Lucas and Luna explore how a fintech startup slashed its Kubernetes bill by 35 percent by hibernating non-production clusters during off-hours. They break down the shift in developer mindset, the automation behind turning clusters on and off, and the metrics that proved no one's work was interrupted. Along the way, they discuss the hidden costs...

When a fintech startup's core service started OOM-killing pods every few hours, engineer Priya Patel didn't reach for a bigger instance. Instead, she profiled the Java heap and found that a single data structure — a ConcurrentHashMap holding cache entries — was responsible for over half the resident memory. In this episode, Lucas and Luna walk through how Priya replaced it with a custom, off-heap...

In this episode of The Software Engineering Podcast, Lucas and Luna dig into the surprisingly large carbon footprint of software. They break down how a single engineer at a mid-sized SaaS company cut their cloud bill and their CO2 emissions by 30 percent through a mix of carbon-aware scheduling and right-sizing. They explain what carbon-aware computing actually means, why running batch jobs when t...