# coupling

Published articles for coupling.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Jira Service Management Projects: Consolidation Versus Splitting at Scale

DevFeed: [Jira Service Management Projects: Consolidation Versus Splitting at Scale](<https://devfeed.tech/articles/when-atlas-meets-the-hyperscale-34016.md>)

Original publisher: [Read original article](<https://sridharrajarao.com/blog/jsm-projects-atlassian-vs-hyperscalers/>)

Author: Sridhar Rajarao

Published: 2026-07-28T00:00:00Z

Content type: opinion

Language: en

Sources: [Sridhar Rajarao](<https://devfeed.tech/sources/sridhar-rajarao.md>)

Topics: [jira](<https://devfeed.tech/topics/jira.md>), [atlassian](<https://devfeed.tech/topics/atlassian.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Security](<https://devfeed.tech/topics/security.md>)

Tags: [atlassian](<https://devfeed.tech/tags/atlassian.md>), [compliance](<https://devfeed.tech/tags/compliance.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [deployments](<https://devfeed.tech/tags/deployments.md>), [incident-management](<https://devfeed.tech/tags/incident-management.md>), [jira](<https://devfeed.tech/tags/jira.md>), [jsm](<https://devfeed.tech/tags/jsm.md>), [security](<https://devfeed.tech/tags/security.md>), [sre](<https://devfeed.tech/tags/sre.md>), [tooling](<https://devfeed.tech/tags/tooling.md>)

### AI overview

The article compares Atlassian's recommendation to consolidate Jira Service Management work into fewer projects with the multi-project approach used by hyperscalers. It argues that consolidation suits smaller organizations, while separate projects can provide stronger security boundaries, limit configuration blast radius, and preserve team autonomy at scale.

### Source excerpt

Atlassian recommends consolidation. Hyperscalers use many. Both are right for different problems. Five real reasons to split, and what works at each scale.

## TBM 430: Incubate, Compound, Refinance, Liquidate

DevFeed: [TBM 430: Incubate, Compound, Refinance, Liquidate](<https://devfeed.tech/articles/tbm-430-incubate-compound-refinance-liquidate-40056.md>)

Original publisher: [Read original article](<https://cutlefish.substack.com/p/tbm-430-incubate-compound-refinance>)

Author: John Cutler

Published: 2026-07-12T20:57:05Z

Content type: opinion

Language: en

Sources: [The Beautiful Mess](<https://devfeed.tech/sources/the-beautiful-mess.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Software](<https://devfeed.tech/topics/software.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [cost](<https://devfeed.tech/tags/cost.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [product](<https://devfeed.tech/tags/product.md>), [value](<https://devfeed.tech/tags/value.md>)

### AI overview

This opinion article combines software portfolio economics with AI, arguing that AI does not remove complexity, coupling, coordination, uncertainty, or decay. Instead, it can change the cost, speed, and feasibility of responding to them. The article uses a value-versus-carrying-cost model to describe software assets as incubate, compound, refinance, or liquidate cases.

### Source excerpt

tl;dr: AI does not eliminate complexity, coupling, coordination, uncertainty, or decay.

## Your event-driven architecture is a distributed monolith -- and that's fine, if you measure it

DevFeed: [Your event-driven architecture is a distributed monolith -- and that's fine, if you measure it](<https://devfeed.tech/articles/your-event-driven-architecture-is-a-distributed-monolith-and-that-s-fine-if-you-measure-it-38795.md>)

Original publisher: [Read original article](<https://fidelitas.io/2026/05/event-driven-distributed-monolith/>)

Author: fidelitas.io

Published: 2026-05-15T10:30:00Z

Content type: opinion

Language: en

Sources: [fidelitas.io](<https://devfeed.tech/sources/fidelitas-io.md>)

Topics: [event driven](<https://devfeed.tech/topics/event-driven.md>), [Messaging](<https://devfeed.tech/topics/messaging.md>), [Structured-data](<https://devfeed.tech/topics/structured-data.md>), [Traces](<https://devfeed.tech/topics/traces.md>), [interface](<https://devfeed.tech/topics/interface.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [decoupling](<https://devfeed.tech/tags/decoupling.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [event-driven-architecture](<https://devfeed.tech/tags/event-driven-architecture.md>), [messaging](<https://devfeed.tech/tags/messaging.md>), [observability](<https://devfeed.tech/tags/observability.md>), [schemas](<https://devfeed.tech/tags/schemas.md>), [services](<https://devfeed.tech/tags/services.md>), [traces](<https://devfeed.tech/tags/traces.md>)

### AI overview

This opinion article argues that event-driven systems can become distributed monoliths when message brokers hide rather than remove coupling. It focuses on explicit, versioned, validated schemas and traces as ways to reveal dependencies and diagnose failures.

### Source excerpt

Async messaging didn't decouple your services; it hid the coupling. Here's how to find the seams again with traces, schemas, and a healthy fear of fan-out.

## Programming Priorities

DevFeed: [Programming Priorities](<https://devfeed.tech/articles/programming-priorities-38390.md>)

Original publisher: [Read original article](<https://blog.danlew.net/2025/03/11/programming-priorities/>)

Author: Dan Lew

Published: 2025-03-11T14:00:44Z

Content type: opinion

Language: en

Sources: [Dan Lew Blog](<https://devfeed.tech/sources/dan-lew-blog.md>)

Topics: [Maintainability](<https://devfeed.tech/topics/maintainability.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Development](<https://devfeed.tech/topics/development.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>)

Tags: [automated](<https://devfeed.tech/tags/automated.md>), [code](<https://devfeed.tech/tags/code.md>), [code-design](<https://devfeed.tech/tags/code-design.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [decoupling](<https://devfeed.tech/tags/decoupling.md>), [development](<https://devfeed.tech/tags/development.md>), [maintainability](<https://devfeed.tech/tags/maintainability.md>), [programming](<https://devfeed.tech/tags/programming.md>), [readability](<https://devfeed.tech/tags/readability.md>), [software](<https://devfeed.tech/tags/software.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [tests](<https://devfeed.tech/tags/tests.md>)

### AI overview

This article presents a priority order for code design: functionality first, maintainability second, and other concerns afterward. It argues that maintainable code reduces the time and risk involved in future changes, allowing later refactoring and optimization. Suggested practices include automated tests, good architecture, decoupling, encapsulation, readable code, and useful comments.

### Source excerpt

Software development (or, you know, life in general) is all about juggling priorities. For this post, I'm thinking specifically about code design priorities. You only have a limited amount of time to implement a feature, so you have to pick and choose which aspects of it to spend

## Building resilient event-driven architecture for finance with Temporal

DevFeed: [Building resilient event-driven architecture for finance with Temporal](<https://devfeed.tech/articles/building-resilient-event-driven-architecture-for-finance-with-temporal-35750.md>)

Original publisher: [Read original article](<https://temporal.io/blog/building-resilient-event-driven-architecture-for-finserv-with-temporal>)

Author: Tim Imkin

Published: 2025-01-23T00:00:00Z

Content type: tutorial

Language: en

Sources: [Temporal Blog](<https://devfeed.tech/sources/temporal-blog.md>)

Topics: [event driven](<https://devfeed.tech/topics/event-driven.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Orchestration](<https://devfeed.tech/topics/orchestration.md>), [reliability](<https://devfeed.tech/topics/reliability.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [Microservice](<https://devfeed.tech/topics/microservice.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>)

Tags: [business-logic](<https://devfeed.tech/tags/business-logic.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [crashes](<https://devfeed.tech/tags/crashes.md>), [databases](<https://devfeed.tech/tags/databases.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [error-handling](<https://devfeed.tech/tags/error-handling.md>), [event-driven-architecture](<https://devfeed.tech/tags/event-driven-architecture.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [orchestration](<https://devfeed.tech/tags/orchestration.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [retries](<https://devfeed.tech/tags/retries.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [temporal-concepts](<https://devfeed.tech/tags/temporal-concepts.md>)

### AI overview

This article examines the complexity of choreography-based event-driven architecture in financial services, including fragmented business logic, design-level coupling, decentralized error handling, and limited observability. It presents Temporal's durable execution and workflow orchestration as a centralized approach for building more resilient and maintainable systems.

### Source excerpt

Discover how Temporal simplifies event-driven systems, replacing complexity with scalability, reliability, and centralized workflows.

## Event-driven systems and the truth about "loosely coupled" architectures

DevFeed: [Event-driven systems and the truth about "loosely coupled" architectures](<https://devfeed.tech/articles/event-driven-systems-and-the-truth-about-loosely-coupled-architectures-35828.md>)

Original publisher: [Read original article](<https://temporal.io/blog/event-driven-systems-and-the-truth-about-loosely-coupled-architectures>)

Author: Erica Sadun

Published: 2024-12-04T16:00:00Z

Content type: article

Language: en

Sources: [Temporal Blog](<https://devfeed.tech/sources/temporal-blog.md>)

Topics: [event driven](<https://devfeed.tech/topics/event-driven.md>), [Resilience](<https://devfeed.tech/topics/resilience.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Developer experience](<https://devfeed.tech/topics/developer-experience.md>)

Tags: [architectures](<https://devfeed.tech/tags/architectures.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [developer-experience](<https://devfeed.tech/tags/developer-experience.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [resilience](<https://devfeed.tech/tags/resilience.md>), [scale](<https://devfeed.tech/tags/scale.md>), [services](<https://devfeed.tech/tags/services.md>), [systems](<https://devfeed.tech/tags/systems.md>), [temporal-concepts](<https://devfeed.tech/tags/temporal-concepts.md>), [troubleshooting](<https://devfeed.tech/tags/troubleshooting.md>)

### AI overview

This article explains how event-driven architectures use independently operating services and message-based communication to support scalability and resilience. It discusses tradeoffs including coupling, troubleshooting, and developer experience, and describes how Temporal abstracts failure and retry logic.

### Source excerpt

Explore the challenges of event-driven systems and how loosely coupled architectures improve developer experience and troubleshooting.

## How coupling distinguishes monoliths, microservices, and serverless architectures

DevFeed: [How coupling distinguishes monoliths, microservices, and serverless architectures](<https://devfeed.tech/articles/monoliths-microservices-and-serverless-aren-t-what-you-think-they-are-39078.md>)

Original publisher: [Read original article](<https://blog.devdetails.com/p/monoliths-microservices-and-serverless>)

Author: Mike

Published: 2024-01-19T05:42:25Z

Content type: opinion

Language: en

Sources: [Dev Details](<https://devfeed.tech/sources/dev-details.md>)

Topics: [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Microservice](<https://devfeed.tech/topics/microservice.md>), [Microservices](<https://devfeed.tech/topics/microservices.md>), [Serverless](<https://devfeed.tech/topics/serverless.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [DynamoDB](<https://devfeed.tech/topics/dynamodb.md>)

Tags: [coupling](<https://devfeed.tech/tags/coupling.md>), [database](<https://devfeed.tech/tags/database.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [dynamodb](<https://devfeed.tech/tags/dynamodb.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [monolith](<https://devfeed.tech/tags/monolith.md>), [serverless](<https://devfeed.tech/tags/serverless.md>)

### AI overview

This article examines how to distinguish monoliths, microservices, and serverless architectures. It argues that deployment coupling and dependencies matter more than the number of repositories, containers, lambdas, teams, or database servers. Applications that must be redeployed together are described as parts of a distributed monolith, while microservices are characterized by how tightly coupled they are to dependencies, one another, and data.

### Source excerpt

Or are they?

## Apache Cassandra in a Microservices Enterprise Platform

DevFeed: [Apache Cassandra in a Microservices Enterprise Platform](<https://devfeed.tech/articles/apache-cassandra-in-a-microservices-enterprise-platform-31994.md>)

Original publisher: [Read original article](<https://tech.finn.no2015/04/28/Apache-Cassandra-in-a-Microservices-Enterprise-Platform/>)

Author: mick

Published: 2015-04-28T14:00:00Z

Content type: article

Language: en

Sources: [Finn.no](<https://devfeed.tech/sources/finn-no.md>)

Topics: [Apache Cassandra](<https://devfeed.tech/topics/cassandra.md>), [Microservice](<https://devfeed.tech/topics/microservice.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Temporal data](<https://devfeed.tech/topics/temporal-data.md>)

Tags: [apis](<https://devfeed.tech/tags/apis.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [cassandra](<https://devfeed.tech/tags/cassandra.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [enterprise](<https://devfeed.tech/tags/enterprise.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [rest](<https://devfeed.tech/tags/rest.md>), [time-series](<https://devfeed.tech/tags/time-series.md>)

### AI overview

The article discusses Apache Cassandra as a persistence layer for microservices platforms, particularly for systems that need scalability and time-series data models. It also outlines microservices practices involving isolated runtime APIs, reduced coupling, REST, and producer-defined schemas for event-driven designs.

### Source excerpt

In this article we'll explore how Apache Cassandra, the world's most popular wide column store and 8th most popular database overall, will only grow as a cornerstone technology in a microservices platform. With a little theory to microservices, to some examples of microservices and underlying required infrastructure, we'll show that any solution both capable of scaling and dealing with time-series data-models is going to need to depend upon Apache Cassandra as a persistence layer, despite having a polyglot persistence model at large. microservices Microservices is a term that's come out of ThoughtWorks' Martin Fowler and James Lewis. It's a bit of a buzzword, basically a fresh revival of the parts of service orientated architecture that you should be focusing on and getting right. A lot of it hopefully is obvious to you already. If you've been doing service orientated architecture or even generally just unix programming properly over the years it might well be frustrating just how buzz "microservices" has become. But it's worth keeping in mind how much garbage we've collected and how many aspects of service orientated architecture that we've gotten badly wrong over the years. Younger programmers certainly deserve the clarity that ThoughtWorks is giving us here. Microservices, following the tips and guidelines from Sam Newman, can basically be broken down into four groups. interfaces Ensure that you standardise the systems architecture at large and especially the gaps or what we know as the APIs between services. Standardise upon practices and protocols that minimise coupling. Move from tightly coupled systems with many compile time dependencies and distributed published client libraries, to clearly defined and isolated runtime APIs. Take advantage of REST, especially level 3 in richardson's maturity model, for the synchronous domain driven designed parts of your system. When it comes to event driven design use producer defined schemas, like that offered by Apache Th

## My Answers for Microservices Awkward Questions

DevFeed: [My Answers for Microservices Awkward Questions](<https://devfeed.tech/articles/my-answers-for-microservices-awkward-questions-31916.md>)

Original publisher: [Read original article](<http://blog.jayfields.com/2015/03/my-answers-for-microservices-awkward.html>)

Author: Jay (noreply@blogger.com)

Published: 2015-03-15T21:48:00Z

Content type: opinion

Language: en

Sources: [Jay Fields](<https://devfeed.tech/sources/jay-fields.md>)

Topics: [Microservices](<https://devfeed.tech/topics/microservices.md>), [Development](<https://devfeed.tech/topics/development.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>)

Tags: [coupling](<https://devfeed.tech/tags/coupling.md>), [experience-report](<https://devfeed.tech/tags/experience-report.md>), [independent](<https://devfeed.tech/tags/independent.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [software-development](<https://devfeed.tech/tags/software-development.md>)

### AI overview

An experience report about developing several small, independently deployable codebases that collaborate to provide a single user experience. The author explains that reducing accidental coupling, rather than adopting microservices as a goal, motivated the approach, while noting that the choice involves tradeoffs and is not universally applicable.

### Source excerpt

Earlier this year, Ade published Awkward questions for those boarding the microservices bandwagon. I think the list is pretty solid, and (with a small push from Ade) I decided to write concise details on my experience. I think it's reasonable to start with a little context building. When I started working on the application I'm primarily responsible for microservices were very much fringe. Fred George was already giving (great) presentations on the topic, but the idea had gained neither momentum nor hype. I never set out to write "microsevices"; I set out to write a few small projects (codebases) that collaborated to provide a (single) solid user experience. I pushed to move the team to small codebases after becoming frustrated with a monolith I was a part of building and a monolith I ended up inheriting. I have no idea if several small codebases are the right choice for the majority, but I find they help me write more maintainable software. Practically everything is a tradeoff in software development; when people ask me what the best aspect of a small services approach is, I always respond: I find accidental coupling to be the largest productivity drain on projects with monolithic codebases. Independent codebases reduce what can be reasonably accidentally coupled. As I said, I never set out to create microservices; I set out to reduce accidental coupling. 3 years later, it seems I have around 3 years of experience working with Microservies (according to the wikipedia definition). I have nothing to do with microservices advocacy, and you shouldn't see this entry as confirmation or condemnation of a microservices approach. The entry is an experience report, nothing more, nothing less. On to Ade's questions (in bold). Why isn't this a library?: It is. Each of our services compile to a jar that can be run independently, but could just as easily be used as a library. What heuristics do you use to decide when to build (or extract) a service versus building (or extracting