Architecture Corner

🎙️ From TokenMaxxing to TokenMining 02.07.2026 6min

Architecture Corner Newsletter PodcastAI coding budgets are getting torched, and 2026 is the year the bill finally came due. In this episode, we dig into how token consumption became a productivity metric (and why that backfired), and what the industry is doing about it now that the free-for-all is ending.We will cover:Why token usage became a proxy for developer productivity — and how Goodhart's Law caught up with itThe provider-side shifts (usage windows, model restrictions, pricing model changes) that reshaped agentic coding through early 2026What's really driving your AI bill: subscriptions vs. API, caching mechanics, and model/thinking-effort tradeoffsPractical tokenmining strategies — from scripting deterministic steps to tuning your harness and mixing modelsWhere the industry goes next as cost-conscious AI development becomes the normDon't forget to subscribe to our newsletter at https://architecturecorner.dev.For more details on the topic discussed in this article, check here (https://medium.com/itnext/from-tokenmaxxing-to-tokenmining-cd2756961176)

Using Open Telemetry to monitor what your coding agent is doing 02.06.2026 4min

Are you flying blind with your AI coding agent?In this episode, we detail what actually happens inside tools like GitHub Copilot and Claude Code beyond the prompt you type.We cover: How LLMs use context windows (and why they "forget") The sharp quality drop that hits at ~40% context usage How to use OpenTelemetry to observe token usage, traces, and system prompts in real timeDon't forget you can subscribe, for free to the Architecture Corner Newsletter at https://architecturecorner.dev

The Challenges of Evolving Your Service: API Versioning 14.03.2026 5min

Once you ship a public API, you've made a promise. Keeping it while still moving forward turns out to be harder than most teams expect.In this episode, we will cover:What qualifies as a backward-compatible change, and what doesn'tWhy does introducing a new API version cost more than just writing new codeThe real reason clients delay upgrades, and what you can do about itHow to support multiple versions without duplicating your entire codebaseThe adapter pattern is a practical way to isolate version changes at the edgesKnow more here: https://medium.com/itnext/the-challenges-of-evolving-your-service-api-versioning-8008349a1154Subscribe, for free, to the Architecture Corner Newsletter at https://architecturecorner.substack.com

Stop Chasing Updates: Building a Sustainable AI Coding Workflow 26.01.2026 5min

The AI development landscape keeps shifting, leaving many developers frustrated as they try to keep up with each new model, tool, and workflow. But what if the answer isn't chasing every update, but building a more intentional approach?In this episode, we will cover:How custom instructions can reduce repetitive prompting and improve consistencyUsing MCP servers to connect your AI tools with external data and servicesThe role of skills in capturing reusable workflowsWhen background agents make sense for your development processStrategies for adapting your workflow as tools evolve without constant disruptionCheck more details here.Subscribe for free to the Architecture Corner Newsletter at https://architecturecorner.substack.com

Managing Trade-offs and Continuous Improvements: DynamoDB multi-attribute Keys 02.12.2025 4min

Welcome to the Architecture Corner PodcastIn this edition, we will explore the pros and cons of DynamoDB as a backdrop to talk about the evolution and trade-offs that any architect will have to make.If you want to know more, check the full article at https://medium.com/itnext/managing-trade-offs-and-continuous-improvements-dynamodb-multi-attribute-keys-4eeb0019d79fAnd subscribe, for free, to the Architecture Corner Newsletter at https://architecturecorner.substack.com

Spec-Driven Development: A Structured Approach to AI-Assisted Coding 20.10.2025 17min

Architecture Corner Newsletter Podcast – where we explore practical frameworks and tools that shape how we build software in the AI era.As AI coding assistants become commonplace, the industry is moving beyond simple prompt-and-pray approaches toward more structured methodologies. This episode examines spec-driven development and how it bridges the gap between traditional software practices and AI-powered code generation.In this episode we will cover:The evolution from vibe coding to specification-driven AI developmentHow SpecKit structures the development process through constitutions, specifications, and implementation plansThe workflow from requirements to code generation, including quality checkpointsReal-world experiences with both new and existing projectsWhen a formal process adds value versus when it becomes overheadThe trade-offs between speed and governance in AI-assisted developmentFor more details check ⁠⁠here⁠.If you are interested in more information about software development and architecture, subscribe for free to our ⁠⁠newsletter⁠⁠.---https://architecturecorner.substack.com

Software Estimations and Agile: Finding the Balance 23.09.2025 6min

Architecture Corner Newsletter Podcast - where we explore the practical challenges of software development and discover actionable solutions for real-world scenarios.Estimations and agile methodologies often seem at odds with each other, creating tension in development teams. Many developers struggle with providing meaningful estimates while embracing agile's flexibility, leading to either over-rigid planning or complete abandonment of forecasting.In this episode we will cover:Common misconceptions about software estimations and their actual purposeWhy agile teams still need planning despite embracing changeThe cone of uncertainty and how it affects project predictabilityWork breakdown structure (WBS) as a practical estimation techniqueHow estimates serve as discussion points rather than commitmentsBalancing flexibility with business realities and budget constraintsStrategies for improving estimation accuracy without sacrificing agilityFor more details, check ⁠here⁠.If you are interested in more information about software development and architecture, subscribe to our ⁠newsletter⁠.----https://architecturecorner.dev

Event Catalog: Advanced Documentation for Event-Driven Systems 27.08.2025 5min

Architecture Corner Newsletter Podcast - exploring documentation strategies that scale with your event-driven architectureEvent Catalog offers capabilities beyond basic service documentation, providing structured approaches to manage complex distributed systems. This episode examines practical features that support enterprise-scale event-driven architectures.In this episode we will cover:Organizational patterns - subdomain modeling and versioning strategies for evolving systemsLifecycle management - deprecation workflows, changelog practices, and governance reportingInfrastructure mapping - channels, flows, and message routing documentationDeployment approaches - single repository vs federated documentation strategiesIntegration capabilities - embedded diagrams, schema generation, and cross-system dependenciesFor more details check ⁠here.If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter.---https://architecturecorner.substack.com

EventCatalog: Building Documentation for Event-Driven Systems 27.08.2025 5min

Architecture Corner Newsletter Podcast explores the tools and practices that make complex software architectures more manageable and maintainable.Event-driven applications often struggle with scattered documentation and poor discoverability of their messaging contracts. EventCatalog emerges as an open-source solution that brings order to this complexity through a documentation-as-code approach.In this episode we will cover:The challenges of documenting both synchronous APIs and asynchronous messaging in modern applicationsHow EventCatalog organizes domains, services, and messages using a structured file-based approachSetting up your first event catalog with commands, events, and queriesIntegrating schema definitions from OpenAPI, AsyncAPI, JSON, and Avro formatsManaging teams, users, and ownership information within your documentationIncorporating Domain-Driven Design concepts like ubiquitous language and entitiesReal-world examples of multi-domain architectures with eCommerce and Fulfillment systemsFor more details check ⁠here.If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.---https://architecturecorner.substack.com

Technology Radar: Navigating the "Move Fast" Culture Without Losing Direction 27.08.2025 6min

Architecture Corner Newsletter Podcast. In today's development landscape, teams face constant pressure to accelerate delivery while the AI revolution adds even more urgency to ship faster. But speed without direction can lead to chaos - scattered technology choices, knowledge fragmentation, and the dreaded "Tower of Babel" effect in your tech stack.In this episode we will cover:The hidden costs of uncontrolled technology proliferation in growing teamsWhat technology radars are and why they're becoming essential for maintaining architectural coherenceThoughtWorks' proven classification system: Adopt, Trial, Assess, and HoldPractical steps to build and maintain your own technology radarCommon objections to technology governance and how to address themHow radars serve as decision-making tools rather than innovation blockersFor more details check ⁠here.If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter.---https://architecturecorner.substack.com

The Developer's AI Dilemma - Coding is Dead, Long Live Coding! 26.08.2025 5min

Architecture Corner Newsletter Podcast - The AI revolution has developers split between those declaring code obsolete and others dismissing the hype entirely. But what's the reality behind the headlines about disappearing programming jobs and "vibe coding" taking over?In this episode we will cover:The real story behind the 25% drop in developer job postings and what factors are actually driving market changesUnderstanding "vibe coding" - when to use it and when it becomes problematic for professional developmentPractical strategies for integrating AI tools into your daily workflow, from code completion to multi-file editsEssential techniques for getting the most out of AI assistants through better context and defined standardsWhy developers still have a future, but the skillset is evolving rapidlyNavigating the balance between AI assistance and maintaining coding fundamentalsFor more details check ⁠here⁠.If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.---https://architecturecorner.substack.com

Finding Balance in Software Development — The Importance of Context 26.08.2025 5min

Architecture Corner Newsletter Podcast explores the ongoing debates around software development patterns and practices, examining why developers often find themselves on opposite sides of architectural decisions.In this episode we will cover:The controversy surrounding popular patterns like SOLID principles, hexagonal architecture, and domain-driven designWhy some developers advocate for always using these patterns while others reject them entirelyHow context determines the right architectural approach for your specific situationPractical examples comparing different implementation strategies and their trade-offsThe dangers of adopting tools and methods without understanding their underlying principlesBuilding knowledge within your team to make informed architectural decisionsEstablishing feedback loops to avoid spiraling into over-engineering or under-engineeringFor more details check ⁠here.If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.---https://architecturecorner.substack.com

Step Functions Evolution: JSONata and Simplified I/O Transform Workflow Development 26.08.2025 6min

Architecture Corner Newsletter Podcast explores the latest developments in cloud-native architectures and serverless computing patterns that are reshaping how we build distributed systems.In this episode we will cover:AWS Step Functions' new JSONata support and how it shifts functionality from Lambda functions to the state machine itselfThe introduction of variables and simplified Input/Output processing that reduces complexity for developersReal-world examples of replacing custom Lambda code with JSONata expressions for filtering, calculations, and data transformationsTrade-offs between low-code approaches and traditional development practices, including testing considerationsStrategic guidance on when to leverage these new capabilities versus maintaining custom code solutionsFor more details check ⁠here⁠.If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.---https://architecturecorner.substack.com

Multi-Region Active-Active Patterns: Building for True High Availability 25.08.2025 7min

Architecture Corner Newsletter PodcastWhen disaster strikes and takes down an entire region, can your application keep serving users without missing a beat? Multi-region active-active setups promise the shortest recovery times, but they come with their own set of challenges around data synchronization, routing, and complexity trade-offs.In this episode we will cover:The three core patterns for active-active architectures: Read Local/Write Global, Read Local/Write Partitioned, and Read Local/Write LocalHow to handle the fundamental requirements of name resolution, application synchronization, and data replicationManaging race conditions and data consistency across distributed regionsStrategic approaches to selecting which parts of your system truly need active-active treatmentReal-world implementation considerations using cloud services for routing, deployment, and data synchronizationWhen the added complexity and cost of active-active makes sense for your organizationFor more details check ⁠here.If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.---https://architecturecorner.substack.com

Disaster Recovery Strategies for Modern Applications 25.08.2025 7min

Architecture Corner Newsletter Podcast - When redundancy and graceful degradation aren't enough, it's time to think beyond single regions and prepare for the worst-case scenarios that can take down entire data centers.In this episode we will cover:Why single-region availability zones have limitations and when you need multi-region strategiesFour disaster recovery approaches: backup and restore, pilot light, warm standby, and active-active setupsTrade-offs between recovery time, data loss, cost, and operational complexityNon-availability reasons for going multi-region: latency optimization and regulatory complianceHow cloud providers like AWS support different disaster recovery patternsPlanning considerations for geographical distribution of your infrastructureFor more details check ⁠here.If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.---https://architecturecorner.substack.com

Graceful Degradation and Asynchronous Processing for High Availability 25.08.2025 6min

Architecture Corner Newsletter Podcast - When system failures are inevitable, the key isn't preventing them but designing around them. Today we explore practical strategies that keep your applications running when dependencies fail, without breaking the bank on complex infrastructure.In this episode we will cover:Implementing graceful degradation patterns to maintain service during dependency failuresUsing circuit breakers and fallback mechanisms to deliver acceptable user experiencesMoving critical operations to asynchronous flows to eliminate cascading failuresIdentifying application dependencies through BPMN documentation and APM toolsBuilding a degradation scorecard to evaluate which services can operate with default behaviorsReal-world examples from e-commerce scenarios including fraud detection and payment processingWhen to consider more advanced solutions like disaster recovery and active-active setupsFor more details check ⁠here.If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.---https://architecturecorner.substack.com

Redundancy and Persistence: Building Resilient Applications 25.08.2025 7min

Architecture Corner Newsletter Podcast - Application availability isn't just about uptime percentages; it's about designing systems that gracefully handle failure through strategic redundancy and data persistence patterns.In this episode we will cover:Redundancy fundamentals - How load balancers and reverse proxies distribute traffic across multiple instances and the challenges of maintaining consistent behavior across replicasStateless vs stateful considerations - Why stateless services simplify redundancy and the complications that arise with session-dependent applicationsPersistence synchronization strategies - The trade-offs between synchronous and asynchronous data replication, including potential data loss and consistency challengesAWS managed solutions - Real-world examples from RDS, Aurora, and DynamoDB showcasing different approaches to multi-AZ redundancy and their availability guaranteesThe consistency spectrum - Understanding eventual consistency versus strong consistency and when to choose each approach for read operationsFor more details check ⁠here⁠.If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.---https://architecturecorner.substack.com

The Real Cost of High Availability: Beyond the Five Nines 25.08.2025 4min

Architecture Corner Newsletter Podcast — When your application goes down, every second counts. But what does it really take to achieve those coveted availability percentages, and more importantly, what are you willing to pay for them?In this episode we will cover:Understanding availability metrics and what "five nines" actually means in practiceThe hidden costs and complexity that come with redundancy strategiesWhy treating all application components equally can drain your resourcesHow to prioritize system components using tier-based availability targetsTrade-offs between operational costs and reliability guaranteesStrategic approaches to balancing business needs with technical constraintsFor more details check here.If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.---https://architecturecorner.substack.com

Don't Ask Permission To Do Your Job Correctly: Escaping The Technical Debt Trap 25.08.2025 5min

Architecture Corner Newsletter Podcast - Where we tackle the real challenges that keep developers up at night and explore practical solutions for building better software systems.Technical debt consistently ranks as developers' top frustration, but the problem runs deeper than most teams realize. The issue isn't just accumulating shortcuts - it's falling into what experts call "cruft" instead of true technical debt, creating a vicious cycle that eventually forces you to ask permission to do your job properly.In this episode we will cover:The critical distinction between legitimate technical debt and harmful cruftWhy the "quick and dirty" approach backfires faster than you thinkThe three essential criteria that separate strategic shortcuts from accumulated messClean code principles that work even when building deliberate technical debtHow to implement the "boy scout approach" for gradual codebase improvementManagement strategies for properly budgeting and scheduling debt repaymentCommunication techniques to align stakeholders on technical trade-offsPractical examples of building clean, incremental solutions under time pressureFor more details check ⁠here⁠.If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.---https://architecturecorner.substack.com

Load Testing Serverless & Asynchronous Systems: Beyond Traditional Approaches 25.08.2025 4min

Architecture Corner Newsletter Podcast explores the complexities of modern distributed systems and the evolving practices needed to ensure their reliability at scale.In this episode we will cover:Why traditional load testing falls short for serverless and asynchronous architecturesThe hidden bottlenecks that synchronous response times can't revealMeasuring what matters: from message queuing to execution completionCloud provider quotas and scaling limitations that catch teams off guardPractical strategies for testing distributed systems with mixed synchronous and asynchronous componentsKey considerations when your infrastructure promises infinite scale but reality delivers constraintsFor more details check ⁠here⁠.If you are interested in more information about software development and architecture, subscribe for free to our ⁠newsletter⁠.