Microservices is the software industry’s most successful confidence scam. It convinces small teams that they are “thinking big” while systematically destroying their ability to move at all. It flatters ambition by weaponizing insecurity: if you’re not running a constellation of services, are you even a real company? Never mind that this architecture was invented to cope with organizational dysfunction at planetary scale. Now it’s being prescribed to teams that still share a Slack channel and a lunch table.
Small teams run on shared context. That is their superpower. Everyone can reason end-to-end. Everyone can change anything. Microservices vaporize that advantage on contact. They replace shared understanding with distributed ignorance. No one owns the whole anymore. Everyone owns a shard. The system becomes something that merely happens to the team, rather than something the team actively understands. This isn’t sophistication. It’s abdication.
Then comes the operational farce. Each service demands its own pipeline, secrets, alerts, metrics, dashboards, permissions, backups, and rituals of appeasement. You don’t “deploy” anymore—you synchronize a fleet. One bug now requires a multi-service autopsy. A feature release becomes a coordination exercise across artificial borders you invented for no reason. You didn’t simplify your system. You shattered it and called the debris “architecture.”
Microservices also lock incompetence in amber. You are forced to define APIs before you understand your own business. Guesses become contracts. Bad ideas become permanent dependencies. Every early mistake metastasizes through the network. In a monolith, wrong thinking is corrected with a refactor. In microservices, wrong thinking becomes infrastructure. You don’t just regret it—you host it, version it, and monitor it.
The claim that monoliths don’t scale is one of the dumbest lies in modern engineering folklore. What doesn’t scale is chaos. What doesn’t scale is process cosplay. What doesn’t scale is pretending you’re Netflix while shipping a glorified CRUD app. Monoliths scale just fine when teams have discipline, tests, and restraint. But restraint isn’t fashionable, and boring doesn’t make conference talks.
Microservices for small teams is not a technical mistake—it is a philosophical failure. It announces, loudly, that the team does not trust itself to understand its own system. It replaces accountability with protocol and momentum with middleware. You don’t get “future proofing.” You get permanent drag. And by the time you finally earn the scale that might justify this circus, your speed, your clarity, and your product instincts will already be gone.
@joelreymont I took a course that involved floppy disks to exchange course material & lessons. Handed the answers over to my highschool teacher who emailed them to university. Great times.
@LefterisJP@lorepunk "Standing to the values even if it hurts" - I hope more people be like that. Elon seems to be like that why I like him. But the shitshow that happened yesterday and promoting it is in deep conflict with my other values . A war time leader deserves a respect not a humiliation
As I understand for Ethereum foundation the idea has been for others to launch rollups or L2's & not themselves (them being more of R&D and to grow the network of builders who work in parallel independently also with their own ideas). As the idea to scale with math (and not with hardware) is hard they want others also to experiment in parallel (with ZK and other ideas), come back, report progress, ideas and then build new L1 services for rollups to use so that rollup centric roadmap can be implemented into a reality (scaling with math). This approach has been certainly slower that could have been under a central management but maybe better for longer term. Now feeling that under the @drakefjustin direction the ideas you mentioned are formed into a reality.
@DaveLevine0com I have them pretty often, similar ones, there is an exam or homework that needed to be done but have not prepared, related to the high school or to the University - although it's over 20 years passed from them. Seems I miss those years.
Unpopular opinion: Abstraction kills productivity and readability ⚡
Although code abstraction and dependency injection are good and I understand their importance, but it is true that it does kill readability and take away the natural flow of reading and understanding the code.
There is a fine line between leveraging abstraction and abusing it.
What most people think is a beautiful code where everything is extensible, is actually just a spaghetti code that no one wants to admit, just because it has become "industry standard".
I am not against abstraction and I do agree that abstraction in some proportion is good and healthy, but when you try to abstract every single implementation and offer multiple implementations of everything, you are just making it harder for someone to become productive on your codebase.
Spending hours navigating through 100s of classes and functions just to understand a trivial flow and understanding where to make the change is counterproductive.
I like codebases that are simple to understand, extend, and contribute to. Some really well-written codebases are CPython, Redis, DGraph, and Consul. In a simple natural flow, you will be able to understand every line of code and what it does.
⚡ Fun fact: I did not name or mention any programming language because it is true for all. I am sure you would relate because we all have been there and felt the pain. 🙃
ps: I say stupid things, so folks on the other side, relax and have fun 🙃
https://t.co/cq7hHSdp3b
@MattJamesBoyle Had actually spent a lot of time also building a side-program for HA in Go. That program keeps track of a state in HA & triggers automations & actions in HA. That way it was easier to program complex ideas instead of doing that inside HA. So it's semi, some in HA & some outside.
@MattJamesBoyle I would be doing it again for my own house (if I had second house), but doing for others, its just too expensive relative to time consumed.