# independent

Published articles for independent.

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

## Microservices Deep Dive: Architecting for Scalability and Resilience

DevFeed: [Microservices Deep Dive: Architecting for Scalability and Resilience](<https://devfeed.tech/articles/microservices-deep-dive-architecting-for-scalability-and-resilience-39562.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/10-microservices-architecture/>)

Author: hello@ankit-rana.com

Published: 2026-03-16T00:00:00Z

Content type: tutorial

Language: en

Sources: [Ankit Rana | Mechanical Sympathy](<https://devfeed.tech/sources/ankit-rana-mechanical-sympathy.md>)

Topics: [microservices architecture](<https://devfeed.tech/topics/microservices-architecture.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [Resilience](<https://devfeed.tech/topics/resilience.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Domain-driven design (DDD)](<https://devfeed.tech/topics/domain-driven-design.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [Deployment](<https://devfeed.tech/topics/deployment.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [ci-cd](<https://devfeed.tech/tags/ci-cd.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [deployments](<https://devfeed.tech/tags/deployments.md>), [devops](<https://devfeed.tech/tags/devops.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [domain-driven-design-ddd](<https://devfeed.tech/tags/domain-driven-design-ddd.md>), [incident-response](<https://devfeed.tech/tags/incident-response.md>), [independent](<https://devfeed.tech/tags/independent.md>), [isolation](<https://devfeed.tech/tags/isolation.md>), [layer](<https://devfeed.tech/tags/layer.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [observability](<https://devfeed.tech/tags/observability.md>), [resilience](<https://devfeed.tech/tags/resilience.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [services](<https://devfeed.tech/tags/services.md>), [system-design](<https://devfeed.tech/tags/system-design.md>)

### AI overview

This article explains how microservices replace a tightly coupled monolith with independently deployable services aligned to business capabilities. It covers benefits such as independent scaling, fault isolation, team autonomy, and technology flexibility, while noting the added costs of communication, observability, operations, and data management. It recommends using microservices when domain complexity and scale justify the operational cost, organizing services around bounded contexts, and extracting one domain at a time.

### Source excerpt

Microservices trade deployment simplicity for independent scaling, fault isolation, and team autonomy, and they only pay off once domain complexity and scale justify the operational cost. Align services to bounded contexts, give each its own data store, and extract one domain at a time rather than splitting by technical layer.

## AI Governance: Evaluators/Auditors should compete for quality

DevFeed: [AI Governance: Evaluators/Auditors should compete for quality](<https://devfeed.tech/articles/ai-governance-evaluators-auditors-should-compete-for-quality-40864.md>)

Original publisher: [Read original article](<https://medium.com/@abreslav/ai-governance-evaluators-auditors-should-compete-for-quality-b115d9660d0e?source=rss-e821c45acf49------2>)

Author: Andrey Breslav

Published: 2023-10-04T10:25:20Z

Content type: opinion

Language: en

Sources: [Stories by Andrey Breslav on Medium](<https://devfeed.tech/sources/stories-by-andrey-breslav-on-medium.md>)

Topics: [ai-governance](<https://devfeed.tech/topics/ai-governance.md>), [Responsibility & Safety](<https://devfeed.tech/topics/responsibility-safety.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-governance](<https://devfeed.tech/tags/ai-governance.md>), [ai-safety](<https://devfeed.tech/tags/ai-safety.md>), [audits](<https://devfeed.tech/tags/audits.md>), [evals](<https://devfeed.tech/tags/evals.md>), [evaluations](<https://devfeed.tech/tags/evaluations.md>), [governance](<https://devfeed.tech/tags/governance.md>), [independent](<https://devfeed.tech/tags/independent.md>)

### AI overview

The author argues that independent evaluations and audits of large AI models may become useful and commercially important but face unclear standards, weak independence, and poor incentives for evaluators to improve. The proposed solution is to make evaluators compete for quality through economic incentives, including a possible bounty funded by a share of each training run's cost.

### Source excerpt

This post is part of a short series on AI Governance. I've recently completed the learning portion of the AI Governance course from BlueDot Impact, and it made me think :) In these posts, I'm writing down some thoughts that crossed my mind and that I haven't seen written down yet. I'm not claiming I'm the first person to come up with these as I haven't done a proper literature review, and I'd be happy to talk to people working on something similar, so please reach out if you are interested.These are very coarse drafts. I'm not trying to provide all the necessary context or references. This will probably only make sense to those people who have been looking into AI Governance lately. I think that governments will demand independent evals/audits for large models soon enough. Here's one particular initiative in this vein: some US senators propose a lot of things, including independent audits. Some people already work on some evals/audits, e.g. ARC Evals or Apollo Research. I'm setting aside the difference between evals and audits as I don't think it's relevant to this discussion. While evals/audits are unlikely to be sufficient, I think they can be very useful. I also think they have a very good chance of becoming a lucrative business. However, there are at least these issues: we don't have good definitions of what an evaluator is looking for; "signs of dangerous capabilities" + an incomplete list of examples is pretty much as good as we could define it so far; the independence of evaluators is not guaranteed by anything; the easiest an AI lab can do to remain compliant is to look for the worst-quality evaluator on the market who won't find anything; evaluators are not economically incentivised to improve their methods; simply licensing them won't help because we don't know what to license for. I'm not saying AI labs or evaluators are malicious. I just believe in behavioural economics, let's put it this way :) Proposed solution: set evaluators up to compete for quality

## Postgres HA: roles are dynamic

DevFeed: [Postgres HA: roles are dynamic](<https://devfeed.tech/articles/postgres-ha-roles-are-dynamic-34616.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2021/12/postgres-ha-roles-are-dynamic/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2021-12-14T21:36:36Z

Content type: tutorial

Language: en

Sources: [Dimitri Fontaine](<https://devfeed.tech/sources/dimitri-fontaine.md>)

Topics: [rdbms](<https://devfeed.tech/topics/rdbms.md>), [Availability](<https://devfeed.tech/topics/availability.md>), [Resilience](<https://devfeed.tech/topics/resilience.md>), [configuration](<https://devfeed.tech/topics/configuration.md>)

Tags: [configuration](<https://devfeed.tech/tags/configuration.md>), [failover](<https://devfeed.tech/tags/failover.md>), [high-availability](<https://devfeed.tech/tags/high-availability.md>), [independent](<https://devfeed.tech/tags/independent.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [primary](<https://devfeed.tech/tags/primary.md>), [rdbms](<https://devfeed.tech/tags/rdbms.md>), [resilience](<https://devfeed.tech/tags/resilience.md>), [server](<https://devfeed.tech/tags/server.md>), [standby](<https://devfeed.tech/tags/standby.md>)

### AI overview

This article explains why PostgreSQL high-availability systems require dynamic node roles. Failover can promote a standby node to primary, so a node's current role should not be treated as a fixed architectural property. The article also discusses how PostgreSQL configuration and instance initialization affect role changes, and why separate failover-management software is needed.

### Source excerpt

High-Availability comes with some impact on your architecture choices, in particular when applied to RDBMS such as Postgres. One such impact is the idea of a failover. When implementing database HA, it is usually expected that both the service and the data are maintained available in the face of operational faults. The most common way to implement resilience includes automated (or manual) failover, where a new primary is elected among a list of standby nodes. In other words, as soon as Postgres High-Availability is implemented, the roles of your Postgres nodes are dynamic. The fact that a given node is a primary or a standby at any given point in time ceases to be relevant to understanding your architecture. In fact, the only thing that's now given about the role of a node is that it will change. Otherwise you don't have failover capability, and then, you probably don't have HA in the first place, right? In this article we are going to try and understand what having dynamic roles for Postgres nodes in a HA system means.

## Just care less about not being aligned

DevFeed: [Just care less about not being aligned](<https://devfeed.tech/articles/just-care-less-about-not-being-aligned-39922.md>)

Original publisher: [Read original article](<https://mende.io/blog/just-care-less-about-not-being-aligned/>)

Author: tobi@techunicorn.builders (Tobias Mende)

Published: 2021-11-06T10:12:00Z

Content type: opinion

Language: en

Sources: [Tobias Mende](<https://devfeed.tech/sources/tobias-mende.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>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [autonomy](<https://devfeed.tech/tags/autonomy.md>), [build-times](<https://devfeed.tech/tags/build-times.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [independent](<https://devfeed.tech/tags/independent.md>), [microservices](<https://devfeed.tech/tags/microservices.md>), [software-development-team-topologies-engineering-excellence-organizational-design](<https://devfeed.tech/tags/software-development-team-topologies-engineering-excellence-organizational-design.md>)

### AI overview

The article argues that fast-growing companies should reduce unnecessary alignment requirements by structuring teams and systems for greater independence. It discusses cross-functional units, vertical ownership, microservices, distinct modules, and splitting frontend and backend dependencies.

### Source excerpt

Just care less about not being aligned If you work in a company that is aiming for fast growth, being overly aligned will slow you down as the number of stakeholders increases. If every time I want to introduce a new linting rule I would need to agree with 55 other developers, I will likely not do it. Instead of forcing all units to use the same tech stack, the same code style, the same testing framework and so on, we need to learn to just care less. Of course, the ability to care less depends on the architecture and the company structure. In a monolithic application, it is far more difficult to reduce the impact of units on each other, than in an environment of properly structured microservices. Thus, the goal is to identify and create structures that allow you to care less about alignment. The entire idea of cross-functional units is aiming for units to be independent. This is achieved by having units own vertical slices of the system completely, which reduces the need for alignment with other units to a minimum. However, sometimes even cross-functional units can influence each other because of technical dependencies or suboptimal structuring of these units.

## Resurrecting my blog after a six-year hiatus

DevFeed: [Resurrecting my blog after a six-year hiatus](<https://devfeed.tech/articles/resurrecting-my-blog-30657.md>)

Original publisher: [Read original article](<http://bad-concurrency.blogspot.com/2020/03/resurrecting-my-blog.html>)

Author: Michael Barker (noreply@blogger.com)

Published: 2020-03-19T04:14:00Z

Content type: opinion

Language: en

Sources: [Bad Concurrency](<https://devfeed.tech/sources/bad-concurrency.md>)

Topics: [Software](<https://devfeed.tech/topics/software.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [independent](<https://devfeed.tech/tags/independent.md>), [latency](<https://devfeed.tech/tags/latency.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [performance](<https://devfeed.tech/tags/performance.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

The author announces the return of their blog after a six-year gap, explains that they are now an independent software consultant, and signals upcoming posts about recent work, including open-source projects.

### Source excerpt

If you have been a long time follower of my blog you will have noticed that is has been a really long time since I posted any new content. Since my last post six years ago at lot has changed. I no longer work at LMAX an have started out as an independent consultant. If you are part of an organisation looking for assistance in building software, especially if you facing challenges around performance (throughput, latency, scalability, or efficiency) then I might be able to help. My services and contact details are available as http://ephemeris.tech. I am hoping to start posting again about some of the work I've doing more recently and good potion of it will be open source, so there should be plenty to share.

## Robust queue job handling in Craft CMS

DevFeed: [Robust queue job handling in Craft CMS](<https://devfeed.tech/articles/robust-queue-job-handling-in-craft-cms-31291.md>)

Original publisher: [Read original article](<https://nystudio107.com/blog/robust-queue-job-handling-in-craft-cms>)

Author: andrew@nystudio107.com (Andrew Welch)

Published: 2019-08-03T15:37:00Z

Content type: tutorial

Language: en

Sources: [nystudio107 | Articles on modern web development.](<https://devfeed.tech/sources/nystudio107-articles-on-modern-web-development.md>)

Topics: [Content Management System](<https://devfeed.tech/topics/cms.md>), [Job](<https://devfeed.tech/topics/job.md>), [async](<https://devfeed.tech/topics/async.md>)

Tags: [async](<https://devfeed.tech/tags/async.md>), [avoid](<https://devfeed.tech/tags/avoid.md>), [cms](<https://devfeed.tech/tags/cms.md>), [craft](<https://devfeed.tech/tags/craft.md>), [failed](<https://devfeed.tech/tags/failed.md>), [here-s](<https://devfeed.tech/tags/here-s.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [independent](<https://devfeed.tech/tags/independent.md>), [insights](<https://devfeed.tech/tags/insights.md>), [job](<https://devfeed.tech/tags/job.md>), [jobs](<https://devfeed.tech/tags/jobs.md>), [long-running](<https://devfeed.tech/tags/long-running.md>), [queue](<https://devfeed.tech/tags/queue.md>), [runner](<https://devfeed.tech/tags/runner.md>), [stalled](<https://devfeed.tech/tags/stalled.md>), [tasks](<https://devfeed.tech/tags/tasks.md>), [uses](<https://devfeed.tech/tags/uses.md>), [using](<https://devfeed.tech/tags/using.md>)

### AI overview

This tutorial explains how Craft CMS queues long-running tasks and why its default web-request-based queue execution can leave jobs stalled or failed. It discusses using an independent async queue runner.

### Source excerpt

Craft CMS uses queue jobs for long-running tasks. Here's how to avoid stalled or failed queue jobs by using an independent async queue runner

## 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

## A Proofless Introduction to Information Theory

DevFeed: [A Proofless Introduction to Information Theory](<https://devfeed.tech/articles/a-proofless-introduction-to-information-theory-40377.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2015/02/16/a-proofless-introduction-to-information-theory/>)

Published: 2015-02-16T09:00:00Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Encoding](<https://devfeed.tech/topics/encoding.md>), [digital](<https://devfeed.tech/topics/digital.md>)

Tags: [channel](<https://devfeed.tech/tags/channel.md>), [coding-theory](<https://devfeed.tech/tags/coding-theory.md>), [communication](<https://devfeed.tech/tags/communication.md>), [compression](<https://devfeed.tech/tags/compression.md>), [digital](<https://devfeed.tech/tags/digital.md>), [encoding](<https://devfeed.tech/tags/encoding.md>), [entropy](<https://devfeed.tech/tags/entropy.md>), [error](<https://devfeed.tech/tags/error.md>), [error-correction](<https://devfeed.tech/tags/error-correction.md>), [example](<https://devfeed.tech/tags/example.md>), [explain](<https://devfeed.tech/tags/explain.md>), [hamming](<https://devfeed.tech/tags/hamming.md>), [independent](<https://devfeed.tech/tags/independent.md>), [information](<https://devfeed.tech/tags/information.md>), [information-theory](<https://devfeed.tech/tags/information-theory.md>), [kolmogorov-complexity](<https://devfeed.tech/tags/kolmogorov-complexity.md>), [language](<https://devfeed.tech/tags/language.md>), [markov](<https://devfeed.tech/tags/markov.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [messages](<https://devfeed.tech/tags/messages.md>), [models](<https://devfeed.tech/tags/models.md>), [probabilistic-method](<https://devfeed.tech/tags/probabilistic-method.md>), [problems](<https://devfeed.tech/tags/problems.md>), [shannon](<https://devfeed.tech/tags/shannon.md>), [theory](<https://devfeed.tech/tags/theory.md>)

### AI overview

A proofless introduction to information theory explains noiseless and noisy communication problems, encoding schemes, entropy, and how entropy differs from Kolmogorov complexity.

### Source excerpt

There are two basic problems in information theory that are very easy to explain. Two people, Alice and Bob, want to communicate over a digital channel over some long period of time, and they know the probability that certain messages will be sent ahead of time. For example, English language sentences are more likely than gibberish, and "Hi" is much more likely than "asphyxiation." The problems are: Say communication is very expensive.