CodeIsGo.com

This article parks a debate about the appropriateness of the microservices approach. While microservices are often touted as the key to scalability and agility, author suggests that the architectural pattern can become a hindrance rather than a help, particularly if implemented without careful consideration. By Dorota Parad.

The article identifies the significant complexities introduced by decentralized architectures, including the challenges of distributed tracing, maintaining data consistency across services, and managing the increased deployment complexity. These factors can lead to higher development and operational costs.

Main points are:

• Microservices are overhyped
• Increased complexity: Microservices architectures introduce significant operational complexity (distributed tracing, inter-service communication, data consistency, deployment).
• Higher costs: The complexity translates to increased development, operational, and maintenance costs.
• Monoliths can be viable: A well-structured monolithic architecture can be a more efficient and cost-effective solution, especially for smaller projects or teams.
• Pragmatic approach needed: Organizations should carefully evaluate their needs and capabilities before adopting microservices, rather than following trends blindly.
• Focus on business value: Architectural decisions should be driven by tangible business value, not just by the desire to implement a popular architectural pattern.

Author argues that many organizations are drawn to microservices simply because they are fashionable, without fully appreciating the organizational and technical investment required. She suggests that a well-designed monolithic architecture can often provide a more efficient and maintainable solution, especially for smaller teams or applications with relatively low complexity. The article ultimately calls for a pragmatic evaluation process, urging teams to analyze their specific needs and infrastructure carefully before adopting microservices and prioritizing tangible business benefits over architectural buzzwords. Nice one!

New research reveals 70% of Kubernetes clusters become neglected within 18 months of deployment - a $9.2B cloud waste problem annually. Paradoxically, Kubernetes adoption continues growing (92% enterprise usage in 2025), with companies like Apple and OpenAI running massive node clusters. By dev engineer.

However, mid-sized organizations particularly struggle with:

• Observability gaps causing “black box” operations
• Multi-team access creating configuration drift
• Persistent storage accumulating like digital hoarding

The article warns that default Kubernetes settings encourage resource bloat, recommending:

• Automated cluster expiration dates
• Namespace quotas with hard deletion policies
• Service mesh integration for usage tracking
• Cross-functional platform teams to maintain ownership

Platform engineering leaders report 40% reduction in zombie clusters after implementing these measures. However, the author cautions that Kubernetes’ flexibility remains a double-edged sword - proper governance must evolve alongside cluster deployments. Good read!

I first encountered Erlang in 2017 while working with RabbitMQ, a message broker built on Erlang. Its ability to handle high concurrency, fault tolerance, and real-time execution made it ideal for our ETL process. Erlang was born at Ericsson in 1986 to power telecom systems demanding “nine-nines” availability (99.9999999% uptime). Open-sourced in 1998, it gained traction beyond telecom, influencing modern messaging apps like WhatsApp and Discord. By James Seconde.

Erlang’s “Let It Crash” philosophy contrasts with traditional defensive programming. Instead of preventing failures, it embraces them, recovering swiftly using supervision trees. This resilience is enabled by the BEAM Virtual Machine, which manages lightweight, isolated processes at lightning speed.

You will also learn about:

• Designed by Ericsson in 1986 for telecom systems needing “nine-nines” uptime (99.9999999%).
• Open-sourced in 1998, leading to widespread adoption in messaging (WhatsApp, Discord) and other fields.
• “Let It Crash” philosophy—failures are embraced, and processes are automatically recovered.
• Runs on the BEAM VM, enabling lightweight concurrency with rapid process switching.
• Supports hot code swapping, allowing live updates without downtime.
• Ideal for IoT, distributed databases (CouchDB, Riak), and real-time systems.
• Erlang remains a top choice for scalable, fault-tolerant applications.

A standout feature is hot code swapping, allowing updates without downtime—a key reason for its success in IoT, distributed databases (like CouchDB and Riak), and messaging systems. Erlang remains a powerful choice for developers needing scalability and reliability. Good read!

Modern DevOps code phases require strategic branching (Trunk-Based, Git Flow, GitHub Flow) to balance speed and stability. Trunk-Based minimizes merge conflicts via feature flags, Git Flow structures releases with dedicated branches, and GitHub Flow streamlines CI/CD through pull requests. Each model impacts team velocity, release cadence, and operational overhead, necessitating alignment with organizational priorities. By Drew Grubb.

Collaboration hinges on Git repositories and rigorous pull request workflows. Microservices architecture decentralizes ownership (teams can use different languages/tools), while linting tools enforce cross-project consistency. These practices reduce technical debt but introduce challenges in API contract management and infrastructure coordination.

The main points discussed in the blog post:

• Collaboration: The backbone of code
• Branching strategies
• Bringing work together & getting it to production
• Pair Programming: Real-time collaboration
• Maintainability: Writing code for the long haul
• Microservices Architecture
• Linting: Enforcing consistency
• Infrastructure as Code (IaC): Dev meets ops

Infrastructure as Code (IaC) with tools like Terraform enables infrastructure parity with application code through version control, automated testing, and pipeline integration. This reduces manual errors and accelerates deployment scaling, though requires disciplined state management to avoid sprawl.

The Code phase’s success depends on harmonizing short-term execution with long-term maintainability. Over-automation risks complexity, while overly rigid structures slow innovation. CTOs must prioritize tooling that supports both rapid iteration and robust governance (e.g., Git hooks for linting, ArgoCD for GitOps). Choose strategies based on team size, release frequency, and infrastructure maturity. Nice one!

Often, I want to play with a Kubernetes cluster without having to pay a cloud provider for compute, or by setting up a home lab cluster with kubeadm. In these times, I reach for K8s Kind (although I’d love to have a home lab cluster). By Ben Burbage.

The core issue stems from ContainerD’s strict TLS certificate validation when pulling images from private registries with self-signed certificates in Kind-based Kubernetes clusters. This manifests as ImagePullBackOff errors during pod deployment, compounded by Kind’s minimal node images lacking standard text editors (vim, nano) for runtime configuration.

The resolution implements a multi-layer configuration approach leveraging ContainerD’s registry configuration system:

• Layer 1 - ContainerD runtime configuration
• Layer 2 - Registry-specific TLS handling
• Layer 3 - Kind integration strategy

The solution enables seamless ArgoCD workflows by ensuring private registry images pull successfully, maintaining the declarative infrastructure approach while accommodating enterprise security requirements. Interesting read!

Kubernetes cluster sprawl occurs when organizations create numerous clusters without proper governance, undermining the platform’s core benefits of automated deployment, scaling, and self-healing. This uncontrolled proliferation stems from Kubernetes’ deployment simplicity combined with governance gaps, innovation pressure, and infrastructure complexity in multi-cloud environments. The resulting sprawl creates operational inefficiencies, security vulnerabilities through inconsistent configurations, and resource waste from abandoned clusters - ultimately leading to loss of visibility across the Kubernetes ecosystem. By Damon Garn, Cogspinner Coaction.

The article described what drives Kubernetes cluster sprawl: * Ease of deployment. Kubernetes’ hallmark deployment simplicity becomes a liability when not governed * Governance vacuum. Like any critical IT * Innovation pressure. Development and deployment teams are under immense pressure to innovate and deliver quickly, possibly causing them to bypass existing cluster management policies perceived as roadblocks * Infrastructure complexity. Multi-cloud and hybrid environments significantly complicate standardization, monitoring and compliance efforts across Kubernetes deployments * Lifecycle management failures. The perception of unlimited compute power, especially in cloud environments, encourages teams to deploy and subsequently abandon clusters without consideration of long-term management

To combat sprawl, implement structured governance with configuration standardization using templates and automated scripts. Adopt centralized management tools for unified oversight across clusters, particularly in large-scale environments. Crucially, balance this control with developer autonomy by implementing automated scaling that dynamically adjusts resources while maintaining innovation capacity. This approach preserves Kubernetes’ agility while preventing technical debt accumulation and maintaining enterprise-wide visibility.

The solution requires treating Kubernetes like other critical infrastructure - with lifecycle management, regular audits, and alignment between deployment velocity and operational governance. Early intervention through these techniques maintains efficiency as containerized workloads grow. Good read!

Three common architectures for modern iOS apps are: MVVM, TCA, and VIPER. This post will talk about using MVVM and TCA for our spec TaskManager app. By Jp.

The TaskManager app leverages MVVM and TCA to handle its three modules (Task, Text, Setting) with consistent functionality.

MVVM Architecture

• Core Concept: ViewModel acts as an intermediary between Model data and SwiftUI views
• TagView Example: A TagView uses a @Observable ViewModel to manage edit mode (active/inactive) and text conversion via convertTagIfValid. The view binds directly to the ViewModel’s state, updating dynamically when user input changes
• Navigation & Data Flow: Master-detail views (e.g., Task list with detail editing) share a central ViewModel. User interactions in child views update parent data through well-defined protocols and business logic encapsulated in the ViewModel

TCA Architecture

• Core Concept: Unidirectional data flow—State → Actions → Reducers ensures immutable state changes driven by explicit user actions
• Task Management Example: A task array is stored in State, manipulated via actions like addButtonTapped, deleteSent, or editTask. Reducers handle all business logic (e.g., validating input before saving), returning new States through effects if needed
• Navigation: Uses destination states to transition between features (e.g., opening an Add/Edit form as a sheet). Actions are strictly defined, and reducers process them immutably to update State

Benefits & Limitations

• MVVM Advantages: Simplified state management via ViewModels; flexible UI updates without heavy boilerplate
• TCA Advantages: Predictable flow, easier testing due to immutable States, and clear separation of concerns (Reducers for logic)
• Challenges in TCA: Increased complexity with deep nested views requiring destination coordination. MVVM’s loose coupling can lead to scattered business logic if not structured carefully

Both architectures achieve consistent functionality across modules but differ in their approach to state management. MVVM prioritizes rapid UI updates via ViewModels, while TCA emphasizes strict flow control for predictability. The choice depends on team familiarity and project complexity—MVVM suits flexible UIs, whereas TCA excels at complex navigation patterns and data integrity. Good read!

Akka’s latest deployment options represent a significant evolution in distributed systems architecture, addressing long-standing challenges in transitioning from development to production environments. The introduction of self-managed nodes and self-hosted Platform regions extends Akka’s “build once, deploy anywhere” philosophy while maintaining the framework’s core technical advantages. By Tyler Jewell.

The self-managed nodes capability allows Akka SDK services to be packaged as standalone Docker containers that can run on any infrastructure—whether public cloud PaaS offerings, Kubernetes clusters, bare metal servers, or edge devices. This approach leverages Akka’s embedded clustering technology, where the clustering logic is built into the service itself rather than relying on external coordination services.

Self-hosted Akka Platform regions represent a more comprehensive deployment option, enabling organizations to run Akka Platform in their own data centers without any dependency on Akka.io’s control planes. This is particularly valuable for organizations with strict compliance requirements, air-gapped environments, or those seeking complete operational sovereignty. The self-hosted model maintains Akka Platform’s automated operations capabilities that handle over 30 maintenance, security, and observability duties, reducing operational overhead while providing full control over the infrastructure.

Key technical implications include:

• Elimination of vendor lock-in while preserving advanced distributed systems capabilities
• Seamless transition from development to production without code changes
• Built-in multi-region data replication supporting 99.9999% availability
• Responsibility shift for operations and maintenance to the organization
• Licensing under BSL 1.1 with commercial options for production use

A significant technical challenge organizations may face is managing the operational complexity of self-managed deployments, particularly around upgrades and security patching, which were previously handled by Akka’s managed services. The frequent platform updates (multiple times per week) necessitate close cooperation with Akka’s SRE team during installation to ensure stability. Good read!

Apache Airflow is a leading open-source tool for workflow orchestration, designed to manage complex tasks in Python. Developed by Airbnb and now part of the Apache Software Foundation, it’s widely adopted for its flexibility and scalability in data engineering workflows. By Rost Glukhov.

Some core concepts or Apache AirFlow debated in the article:

• Workflows as Code: Define entire pipelines using Python, leveraging constructs like loops and conditionals
• Directed Acyclic Graphs (DAGs): Structure workflows with nodes as tasks and edges as dependencies, ensuring no cycles
• Task Management: Use Operators (e.g., PythonOperator) to execute tasks, which can be custom functions or shell commands
• UI & Monitoring: Airflow’s web interface offers real-time monitoring of task status, logs, and performance metrics

In summary, Apache Airflow is a powerful tool for managing data workflows, offering flexibility, scalability, and robust integration capabilities, making it an essential choice for organizations looking to automate their data pipelines effectively. The article also provides few simple ETL and DAG workflows in Python. Nice one!

After trying out several backup tools over the years, rsnapshot has proven to be one of the most reliable, and setting it up on a Raspberry Pi is easier than you might think. As you know, maintaining our Raspberry Pi infrastructure is crucial. Data loss can disrupt projects and impact efficiency, so we need a robust backup solution. The article highlights rsnapshot, a powerful open-source tool that provides an excellent way to automate incremental backups on our Pis. Let me show you how it all works. By Usman Qamar.

The article then explains:

• Installation: It’s easily installed using apt-get
• Configuration: A simple configuration file allows us to define where snapshots are stored (locally or on a network share), how many versions we retain, and which directories to include in the backup
• Automation with Cron:** We can automate the entire process by scheduling backups using cron jobs
• Remote Backups: For enhanced data protection, consider backing up to a shared folder on our network

Rsnapshot uses rsync to efficiently copy only changed files, saving both time and storage. It creates snapshots – essentially point-in-time copies of your system’s data. The key is its incremental nature; it only backs up what’s changed since the last snapshot. This is far more efficient than full backups, which are time-consuming and consume significant storage. Good read!