Score line (@Live_ScoreLine) header
Score line (@Live_ScoreLine) profile picture

Live score updates Football, Tennis, Formula 1, Golf, Basketball, & Rugby

Kampala
Joined October 2021
Photo by Score line (@Live_ScoreLine)Photo by Score line (@Live_ScoreLine)Photo by Score line (@Live_ScoreLine)Photo by Score line (@Live_ScoreLine)Photo by Score line (@Live_ScoreLine)Photo by Score line (@Live_ScoreLine)Photo by Score line (@Live_ScoreLine)Photo by Score line (@Live_ScoreLine)Photo by Score line (@Live_ScoreLine)Photo by Score line (@Live_ScoreLine)
Discussion: Why isn't Manchester United getting those crosses in and those striker opportunities when Sesko starts up top?
1
1
2
461
Good software isn’t about writing more code. It’s about solving the right problems, managing complexity, designing for failure, and knowing what not to build. This article brings together the biggest software engineering lessons. 👇
6
2
1
6
1,288
AI can write code in seconds. But it cannot save you from problems you don’t understand. It may generate a Django API, connect a database, add authentication, and even write the tests. Then production happens: • Requests become slow • Users submit the same payment twice • Services stop communicating • The database becomes overloaded • Logs show errors nobody understands This is where copying AI-generated code stops working. The developers who will succeed in the AI era are not necessarily those who type code fastest. They are the ones who can: • Break large problems into smaller ones • Understand how systems communicate • Design reliable databases • Debug unexpected behaviour • Review AI-generated code carefully • Make good decisions when there is no perfect answer Use AI to move faster—but keep learning the foundations. Because AI can generate a solution. Understanding tells you whether that solution can survive the real world. I’m learning, building, and sharing the journey—one system at a time. Road to 30K. 🚀
1
1
2
187
I think “we should rewrite it” is one of the most tempting sentences in software engineering. And sometimes it is absolutely the right decision. But a lot of the time, the code is not the only problem. You can rewrite a system in: → a cleaner language → a newer framework → better architecture → better naming → better tests → better infrastructure …and still recreate the same mess. Why? Because the real problems were never only technical. They were things like: → nobody knew who owned which part → requirements kept changing without clear decisions → exceptions became permanent → boundaries were unclear → nobody documented why strange behavior existed → teams kept adding features without removing anything → every urgent request bypassed the normal process If you rewrite the code without fixing those habits… you may simply build a cleaner version of the same problem. Imagine a legacy system everyone hates. It has: → duplicated logic → huge classes → old dependencies → confusing database tables → weird conditionals → years of workarounds The obvious reaction is: “Start again.” New repository. New architecture. Fresh database. Everything clean. It feels amazing. For a while. Then real requirements start arriving. One customer needs an exception. Operations needs a workaround. Management needs a deadline moved forward. A legacy integration behaves strangely. Someone adds a temporary flag. Another team needs direct database access. And slowly… the new system starts looking familiar. That should tell us something. Sometimes the old code is messy because the organization is messy. The software is just recording years of unresolved decisions. That weird conditional may represent a contract with one customer. That duplicate field may exist because two departments disagree on what the value means. That manual approval may exist because nobody wants accountability for removing it. That “temporary” integration may be supporting the most important client. Delete the code without understanding the reason behind it… and you may delete knowledge you didn’t know was there. This is why legacy systems deserve more respect than they usually get. Not because old code is beautiful. But because old systems contain history. Years of: → edge cases → business rules → exceptions → user behavior → mistakes → fixes → compromises Some of those things should absolutely disappear. But first you need to know why they exist. A rewrite that ignores history can take a system from: ugly but understood to: clean but incomplete. And the second one can be much more dangerous. I think teams should ask a different question before rewriting: Not: “How bad is this code?” But: “What is making this system expensive to change?” Those are different questions. Maybe the answer is the architecture. Maybe it’s missing tests. Maybe it’s tight coupling. Maybe it’s poor documentation. Maybe it’s unclear ownership. Maybe it’s a broken release process. Maybe nobody understands the business rules anymore. Maybe one person has become the entire documentation system. A rewrite only directly solves some of those. Sometimes one acceptance test around a critical workflow is more valuable than rewriting 5,000 lines. Sometimes documenting one ugly business rule prevents months of mistakes. Sometimes defining ownership for one subsystem changes everything. Sometimes separating one badly coupled module gives the team enough room to move again. Sometimes deleting unused features is the highest-value architecture work you can do. The solution doesn’t always need to be dramatic. I also think developers underestimate how expensive rewrites really are. Because while the new system is being built… the old system is still alive. Customers still need features. Bugs still need fixes. Security patches still happen. Now your team is maintaining two realities: the system everyone uses and the system everyone hopes to use. That can become exhausting very quickly. And every new feature added to the old system becomes another thing the rewrite must catch up with. The finish line keeps moving. This doesn’t mean: “Never rewrite.” Sometimes the foundation really is the problem. Maybe: → the platform is unsupported → the architecture fundamentally blocks the product → security risk is unacceptable → the language or framework is no longer maintainable → scaling the existing design is becoming more expensive than replacement Those are real reasons. But “the code is ugly” is not always enough. There’s a useful distinction here: A rewrite replaces code. A transformation changes how the team builds software. If the original problems were: poor ownership, weak boundaries, unquestioned requirements, no tests, and uncontrolled complexity… then those need to change too. Otherwise version 2 eventually becomes version 1. Just with better syntax. And AI may make rewrites even more tempting. Today you can take an old module and ask AI to: “Rewrite this cleanly.” Seconds later, you have beautiful-looking code. But AI may not know why the ugly code exists. That strange if statement might look wrong… until you discover it handles the hospital workflow that only happens on weekends. That duplicate calculation might look unnecessary… until you discover one customer uses a different historical rule. Cleaning code without understanding behavior is dangerous. The fastest rewrite is not always the safest rewrite. I think the mature approach is often: Understand first. Protect critical behavior with tests. Document important decisions. Establish ownership. Fix boundaries. Remove what is truly unnecessary. Then decide what actually deserves replacement. Because sometimes the best rewrite is not: “Start again.” It’s: “Make the current system easier to understand and change.” That may not look as exciting in an architecture diagram. But it can create much more value. So developers, be honest: You inherit a painful legacy system tomorrow. What do you do first? A) Rewrite it B) Add tests around critical behavior C) Map dependencies and ownership D) Refactor the worst areas gradually E) Leave it alone until it actually blocks the business What’s your first move? 👇
3
1
1
4
752
“Temporary” code has a strange habit of becoming permanent. Build shortcuts like someone may inherit them.
One of the most expensive words in software development is: “temporary.” Temporary workaround. Temporary endpoint. Temporary database field. Temporary script. Temporary feature flag. Temporary manual process. Temporary integration. And somehow… two years later, the entire system depends on it. 😂 That’s the strange thing about software. The code you expect to throw away often survives much longer than the code you carefully designed. A deadline appears. Someone says: “We just need something that works for now.” Fair enough. So you add a quick condition. Then another customer needs something slightly different. You add another condition. Then an integration depends on that behavior. Then reports start using the data. Then another service assumes the field will always exist. Six months later, someone asks: “Why does this work this way?” And the answer is: “I think it was temporary.” That’s how temporary decisions become architecture. I don’t think shortcuts are automatically bad. Sometimes they are exactly the right decision. Businesses have deadlines. Customers are waiting. Ideas need validation. Not every solution deserves three weeks of architecture discussions. The mistake is not taking the shortcut. The mistake is taking the shortcut without making the debt visible. If you knowingly choose a temporary solution, there should be clarity around it. What are we compromising? Why are we doing it? What could break? When should we revisit it? What happens if we never revisit it? Those questions matter. Because “we’ll fix it later” is not a plan. Later is where software decisions go to become permanent. 😅 Feature flags are a great example. You launch a feature behind a flag. Perfect. The rollout succeeds. Everyone moves on. Three years later: if new_checkout_v2_enabled: ... else: ... Nobody knows whether the else path is still used. Nobody wants to delete it. So both versions remain. Now every checkout change has to consider two realities. That tiny temporary flag has become permanent complexity. The same thing happens with database fields. You create: old_status because migrating everything properly would delay the release. Then you create: new_status. Later somebody needs compatibility. Now both are populated. One report reads old_status. Another API returns new_status. A background job updates both. Congratulations. Your database now contains organizational history. 😂 But here’s the deeper problem: Temporary code rarely stays isolated. Other code begins depending on it. That is when the cost grows. A hack inside one function is manageable. A hack that becomes an API contract is different. A workaround that becomes part of the data model is different. A manual process that becomes an expected business workflow is different. Once other parts of the system depend on a shortcut, removing it becomes much harder. This is why I think one of the most useful engineering questions is: “If this becomes permanent, can we live with it?” That question changes things. You may still choose the quick solution. But perhaps you: → isolate it behind a clear boundary → add a test around the expected behavior → document why it exists → create an explicit cleanup task → avoid exposing it as a permanent contract → keep it away from core domain logic You’re not pretending the shortcut doesn’t exist. You’re containing the damage. There’s another side to this too. Sometimes teams spend too much time making temporary code beautiful. You’re testing an idea that might be deleted next week… and someone wants: → perfect abstractions → complete extensibility → five design patterns → full plugin support That’s also waste. Experimental code should be cheap to throw away. Production code should be safe to keep. The skill is knowing which one you’re writing. And AI makes this even more interesting. Today it is incredibly easy to say: “Just generate a quick solution.” Thirty seconds later, it works. That’s powerful. But quick generated code has the same problem as every other shortcut: If it survives, someone inherits it. Maybe you. Maybe another developer six months later. AI makes temporary code easier to create. It does not make temporary code disappear automatically. So we may need even stronger discipline around: → reviewing generated code → understanding dependencies → removing dead experiments → cleaning old feature flags → documenting strange decisions → refusing to let prototypes quietly become production systems I think every mature codebase contains some historical accidents. That’s normal. The goal is not perfection. The goal is making sure yesterday’s shortcuts don’t control tomorrow’s architecture. Because sometimes the biggest source of complexity in a system is not bad engineering. It’s thousands of reasonable decisions that were supposed to be temporary. So here’s a question for developers: What’s the oldest “temporary” thing still alive in a system you work with? A feature flag? A script? A workaround? A database field? A whole service? 😂 No company names needed. I just want to know how temporary your “temporary” became. 👇
1
1
139
Most technical debt starts with one innocent sentence: “We’ll clean it up later.”
1
1
1
364
The scariest part of a quick fix? It may still be running years after everyone forgot why it exists.
1
1
1
351
Quick fixes are not the problem. Unowned quick fixes are. If nobody knows when to remove them, they become architecture.
The scariest part of a quick fix? It may still be running years after everyone forgot why it exists.
1
1
173
A fast team can still move in the wrong direction. Speed only matters when the feedback loop is strong.
1
2
233
A lot of software projects don’t fail because the developers are bad. They fail because the team is solving the wrong problem. That distinction matters. You can have: → talented engineers → clean code → modern architecture → strong infrastructure → good test coverage → fast deployments …and still build something users don’t want. That is one of the hardest lessons in software development. Because technically, everything can be “correct”… while the product itself is wrong. I’ve seen teams become very good at answering questions like: Should we use microservices? Should this be event-driven? Should we use PostgreSQL or MongoDB? Should we build this in Python, Java, or Go? How should we structure the API? But sometimes the more important questions are still unanswered: Why does this feature need to exist? Who actually needs it? What problem is it solving? How are users solving that problem today? What happens if we don’t build it? Those questions are less exciting. But they’re often more valuable. Imagine you’re building software for a hospital. Management asks for a new digital approval process. The team immediately starts designing: → approval screens → notifications → role permissions → audit logs → escalation rules → dashboards Everything sounds reasonable. But then someone asks: Why does this approval exist in the first place? And nobody has a clear answer. Maybe the original approval was introduced years ago because information wasn’t available electronically. Maybe the system now already has that information. Maybe the approval could disappear completely. If that’s true, the best solution isn’t: a better approval system. It’s: no approval at all. That single question could remove weeks of development… and hours of user frustration every month. This is why requirements should never be treated like unquestionable truth. A requirement is often just somebody’s current idea of the solution. “Add a button.” “Create a report.” “Add another approval.” “Send this through email.” “Let users export this to Excel.” “Build an AI assistant.” Maybe those are the right solutions. Maybe not. A developer who only asks: “How do I build this?” can easily become very efficient at building the wrong thing. A stronger question is: “What problem is this request trying to solve?” There’s an example I really like. A user says: “We need a button that copies customer information from this page to the next one.” Easy feature. You could probably build it quickly. But why are they copying the information? Because the next screen asks for the same information again. Now the problem changes. The requirement was: “Add a copy button.” The actual problem was: “Why are we asking the user to enter the same data twice?” Those lead to completely different systems. And I think AI is going to make this distinction even more important. AI can generate the button. AI can build the API. AI can create the database table. AI can write the tests. AI can even generate the architecture. Implementation is becoming incredibly cheap. But AI doesn’t automatically know whether that feature should exist. So as building gets faster, I think developers will need to become better at something else: questioning assumptions. Not questioning everything just to be difficult. But understanding the reason behind what we build. Because there is another hidden cost to building the wrong feature. You don’t just pay once. After you ship it, you now have to: → maintain it → test it → document it → secure it → support users on it → migrate its data → keep it compatible with future changes → explain it to new developers A bad feature becomes part of the system. Sometimes for years. That’s why deleting unnecessary functionality early can be more valuable than writing it beautifully. We talk a lot about technical debt. But I think there is another kind: product debt. Features that exist but shouldn’t. Workflows everyone hates but nobody questions. Reports nobody reads. Fields nobody understands. Approvals that no longer serve a purpose. Integrations nobody uses. Every one of them makes the system heavier. Eventually the team becomes afraid to remove anything because: “What if someone uses it?” Now the product grows… but clarity disappears. This is why user observation matters so much. Not just surveys. Not just meetings. Actually watching people use the system. You may discover that users: → keep a notebook beside the computer → copy information into Excel → send screenshots through WhatsApp → share passwords → print forms from a digital system → enter fake information to bypass required fields → call someone instead of using a feature you spent months building Developers sometimes call these “bad user habits.” I think they’re often something else: feedback. Users are showing you where the system does not match reality. Workarounds are data. And sometimes what users DON’T use tells you more than what they say. A feature may have taken three months to build. Nobody touches it. That can be painful to accept. But the wrong response is: “Users need more training.” Sometimes they do. But sometimes the feature simply doesn’t solve a meaningful problem. You have to be willing to consider that. I think this is where software development becomes much more than coding. A strong developer should understand code. But a strong software engineer also needs curiosity about: → the business → the workflow → the user → the constraints → the incentives → the consequences of design decisions You don’t need to become the domain expert. But you need to care enough to understand the domain. Because software doesn’t exist inside an IDE. It exists inside someone else’s workday. And that changes how I think about productivity. A developer who writes 2,000 lines this week may be productive. But a developer who asks one question that prevents 20,000 unnecessary lines from being written? That can be far more valuable. Sometimes the highest-leverage engineering contribution is not: “I built it.” It’s: “Do we need to build this at all?” That question can save: → engineering time → infrastructure cost → maintenance burden → user frustration → support work → future technical debt And nobody sees the code you didn’t write. Maybe that’s why software engineering becomes less about coding as you become more experienced. You still need the technical skills. But increasingly, the difficult part becomes judgment. What should exist? What should stay simple? What should be automated? What should be removed? What should we delay? What should never be built? Those decisions shape the product far more than which framework you chose. So here’s a question for developers: You receive a feature request that looks completely reasonable. What do you do first? A) Start designing the solution B) Estimate the work C) Ask why the feature is needed D) Check how competitors built it E) Ask AI to prototype it For me, C changes everything. What would you choose? 👇
4
1
1
3
923
Complexity should be a response to real pain. Not a starting requirement.
1
1
233
Don’t choose technology because it looks impressive. Choose it because removing it would make the system worse.
1
1
214
The right architecture is rarely the most complicated one. It’s the one your team can understand, change, and trust.
1
1
217
You don’t prove experience by adding more layers. Sometimes experience is knowing which layers to leave out.
1
2
235
I think one of the clearest signs of engineering maturity is this: You stop trying to prove how much you know. Early on, it’s easy to think good engineering means using more advanced things. More patterns. More services. More abstractions. More infrastructure. More “enterprise” architecture. You learn about microservices, so you want microservices. You learn Kafka, so suddenly every event needs Kafka. You learn design patterns, so every class needs a pattern. You learn Kubernetes, so every app apparently needs a cluster. But eventually you realize something: Every technical decision creates a cost. Not always today. But eventually. A new service means another thing to deploy. Another database means another thing to back up. Another abstraction means another thing someone has to understand. Another dependency means another thing that can break. Another queue means another failure mode. Another framework means another set of rules your team must live with. Complexity accumulates quietly. And the bill usually arrives later. That’s why I think experienced engineers ask different questions. Not: “Can we use this?” But: “What problem are we solving by adding this?” Not: “Can we split this into microservices?” But: “What pain will splitting it remove?” Not: “Should we add caching?” But: “Do we actually have a performance problem?” Not: “Should we create an abstraction here?” But: “Are these things truly the same, or do they only look similar right now?” That shift matters. Because software systems rarely become difficult because developers didn’t know enough tools. They often become difficult because too many tools were introduced too early. And sometimes the simplest architecture is the hardest one to choose. Why? Because simplicity can feel unimpressive. Imagine two teams building the same product. Team A has: → 12 microservices → Kafka → Kubernetes → Redis → multiple databases → service mesh → event sourcing Team B has: → one well-structured application → PostgreSQL → a background worker → solid monitoring → good tests If both products solve the same problem equally well, Team B isn’t less technical. They may have simply made fewer unnecessary decisions. That’s an important distinction. Simple does not mean poorly designed. A good modular monolith can have: → strong boundaries → clear responsibilities → good domain modeling → proper testing → excellent observability → clean APIs → room to evolve You can design for growth without pretending growth has already happened. That’s the balance. Because overengineering has a strange downside: You start solving the architecture instead of solving the product. Developers spend time asking: “How should these services communicate?” while users are asking: “Why does this page take six clicks?” Teams debate messaging strategies while the core workflow is still wrong. Infrastructure becomes sophisticated while the product remains confusing. That’s backwards. Architecture exists to support the product. The product does not exist to justify the architecture. And this is why “we might need it later” can be such an expensive sentence. Maybe you will. But maybe you won’t. If the system is designed well, you can introduce complexity when the evidence appears. Traffic increases? Scale the bottleneck. Background tasks become heavy? Introduce queues. One module changes far more frequently than the rest? Maybe extract it. Different teams need independent ownership? Now service boundaries may create real value. The database becomes the bottleneck? Solve the database problem you actually have. Let pressure reveal the architecture you need. Don’t try to predict every future problem before you have your first real user. Of course, this doesn’t mean ignoring the future. Good engineering still means thinking ahead. But there’s a big difference between: making change possible and building every future change today. That’s where principles like YAGNI become so valuable. You Aren’t Gonna Need It doesn’t mean: “Never prepare.” It means: Don’t pay today for complexity that has no evidence behind it. And this applies to code too. Sometimes three duplicated lines are fine. Sometimes an interface is unnecessary. Sometimes a function really can just be a function. Sometimes CRUD is genuinely CRUD. Not every piece of code needs to become a reusable framework. The goal isn’t to build code that demonstrates everything you know. The goal is to build software that people can understand, operate, and change. So maybe the question we should ask more often during technical discussions is: “What happens if we DON’T add this?” If the answer is: “Nothing important.” That tells you something. Good engineers know how to add complexity. Great engineers also know when complexity hasn’t earned its place yet. Developers, what’s one technology, pattern, or architectural choice you think teams introduce too early? 👇
1
1
1
1
444
The best tech stack is not the one with the most tools. It’s the one with the fewest unnecessary decisions.
One of the biggest mistakes developers make is choosing technology before understanding the problem. A new project starts and the first conversation becomes: “Should we use Python or Java?” “Django or FastAPI?” “Monolith or microservices?” “PostgreSQL or MongoDB?” “Kubernetes?” “Kafka?” But those are usually not the first questions we should be asking. The first questions should be: Who is using this system? What are they trying to do? What could go wrong? How quickly do we need to ship? Who will maintain this in 2 years? Because technology choices only make sense inside a real context. Take something simple: You’re building an internal system for 40 employees. Do you really need: → Microservices → Kubernetes → Kafka → Multiple databases → Event sourcing → Distributed tracing Probably not. A well-structured monolith with PostgreSQL may serve that company perfectly for years. Now imagine you’re building a payments platform processing millions of transactions. Suddenly things like: → fault tolerance → idempotency → strong consistency → observability → redundancy → security boundaries matter a lot more. Same profession. Completely different engineering decisions. That’s why I don’t think there is such a thing as the “best stack.” There is only the best trade-off for the problem in front of you. Programming language? Don’t ask which one is most popular. Ask: → Does our team know it? → Does its ecosystem support what we need? → Can we hire developers for it? → Can we maintain it long-term? → Does it meet our performance requirements? Python may be perfect for one project. Go may be better for another. Java may be the boring but correct answer somewhere else. Rust may be worth the complexity when safety and performance really matter. The language is a decision. Not an identity. Framework? Frameworks are supposed to save you work. If your product needs authentication, permissions, an admin panel, ORM, forms, and lots of business logic... using a mature framework like Django can be an advantage. If you need a small focused API... something lighter may make more sense. The mistake is choosing a framework because it looks modern rather than because it removes problems you actually have. Architecture? This is where things get interesting. I think a lot of developers confuse architecture with complexity. More services. More layers. More diagrams. More infrastructure. Doesn’t automatically mean better architecture. Good architecture should make important changes easier. If adding one field requires editing: → 4 services → 3 API contracts → 2 queues → a shared library → and a deployment pipeline you may have distributed your code... but you may not have reduced complexity. Sometimes the best architecture is extremely boring. And boring can be a feature. Database? I would also avoid choosing databases based on trends. For many business applications, relational data is still relational data. Users. Orders. Payments. Appointments. Products. Employees. Permissions. There are relationships. There are constraints. There are transactions. PostgreSQL can handle an enormous number of use cases. Use something different when the problem demands something different. Not because you want a more exciting architecture diagram. And then there is scalability. This one causes a lot of unnecessary engineering. Developers sometimes design systems for traffic they don't have. You have: 20 users. But you're designing for: 20 million. Of course scalability matters. But there are two kinds of scalability: Can the infrastructure handle growth? Can developers still understand and change the system as it grows? We talk about the first one constantly. The second one can destroy a company much earlier. A system handling 100 requests per second that the team can safely change may be far more valuable than a system theoretically capable of 1 million requests per second that nobody understands. And here's something else: Your first technology decision does not have to survive forever. This is software. You can evolve it. Start with PostgreSQL. Add Redis when caching actually becomes useful. Add queues when background work becomes necessary. Split a service when you have a clear reason to split it. Introduce more infrastructure when the cost of not introducing it becomes higher than the complexity it creates. Let the architecture respond to real pressure. Not imaginary pressure. I think the real skill in software engineering isn't knowing every tool. It's knowing when a tool is justified. Because almost every technology gives you something... and charges you something. Microservices give independence. They charge operational complexity. Caching gives speed. It charges consistency complexity. Abstractions give flexibility. They charge cognitive complexity. Distributed systems give scalability and resilience. They charge you with network failures, debugging difficulty, and coordination. Even frameworks have a price. Engineering is deciding which prices are worth paying. That is why the answer to so many software questions is: “It depends.” Not because engineers don't know the answer. But because the correct answer depends on the constraints. So here's a real question for developers: You're given a brand-new SaaS idea. Small team. No users yet. You have 90 days to launch. What are you choosing? Language: ? Backend: ? Frontend: ? Database: ? Architecture: ? Hosting: ? Drop your stack below. But there's one rule: You have to explain WHY. 👇
1
1
157
Architecture should grow with the product. Not with the developer’s imagination.
1
1
5
334
I think one of the hardest decisions in software development happens before you write any serious code: How much architecture is enough? You start a new project. At first, everything feels simple. You need: → Users → Authentication → A database → A few APIs → Some business logic Then the engineering brain kicks in. “What if we eventually have 10 million users?” “What if this needs to become a microservice?” “What if we change databases?” “What if we need Kafka?” “What if we deploy across multiple regions?” “What if this service needs independent scaling?” And suddenly your small application has: → 8 services → 3 databases → Redis → Kafka → Kubernetes → API Gateway → Event sourcing → distributed tracing ...and 14 users. 😂 But there is another extreme. You can also build everything in one file, couple every component together, ignore boundaries, and tell yourself: “We'll clean it up when we grow.” Then the product actually grows. And nobody wants to touch anything. So where is the balance? I think the answer is: Design for change, but don't design for imaginary scale. Start simple. But not careless. For many products, I would rather begin with: Frontend ↓ Backend ↓ PostgreSQL Inside the backend: → clear modules → clear responsibilities → good interfaces → tests around important business rules → proper logging → sensible database design That's boring. And that's okay. Then let reality tell you what comes next. If reads become expensive → introduce caching. If tasks take too long → add background workers. If search becomes important → introduce proper search. If one component needs independent scaling → consider extracting it. If teams need independent deployments → microservices may start making sense. If traffic actually becomes enormous → solve the scaling problem you actually have. Architecture should be a response to pressure. Not imagination. And I think this applies to technology choices too. Don't choose Rust because someone posted a benchmark. Don't choose microservices because Netflix uses them. Don't choose Kubernetes because your architecture diagram looks better with it. Don't choose MongoDB because “NoSQL scales.” Don't choose Python because everyone is building AI. Ask: What problem does this technology solve for THIS project? If you can't answer that clearly, you probably don't need it yet. Good architecture isn't the architecture with the most boxes. It's the one that makes today's product easy to build... while keeping tomorrow's important changes possible. That's a difficult balance. Too little architecture creates chaos. Too much architecture creates bureaucracy. The sweet spot is somewhere in the middle. And you usually find it by building, measuring, learning, and adjusting. So developers, I'm curious: You're starting a SaaS product tomorrow with zero users. Would you choose: A) Modular monolith B) Microservices from day one C) Serverless D) Something else And more importantly... why? 👇
1
1
1
1
575
A good architecture should make change easier— not make developers ask permission from 6 services just to add one field.
1
1
185
Starting a new software project? Don’t begin with: “Which language is the best?” Start with: “What problem are we solving, and what constraints do we actually have?” Because there is no universally best language, framework, or architecture. There is only what fits the problem. Here’s how I’d think about it. 1. Start with the product, not the stack Ask: → Who are the users? → Is this internal or public? → How quickly do we need to ship? → How many developers will maintain it? → What integrations are required? → How much traffic do we realistically expect? → What happens if the system goes down? Those answers should influence the technology. Not hype. 2. Choose the language your team can actually maintain Python is great for: → AI → APIs → automation → backend systems → rapid development Java or C# can be excellent for large enterprise systems. JavaScript/TypeScript makes sense when you want strong frontend + backend alignment. Go is attractive when simplicity, concurrency, and deployment efficiency matter. Rust makes sense when performance and safety are critical. The question isn’t: “Which language is fastest?” It’s: “Which language lets this team build and maintain this product safely?” 3. Choose frameworks based on the job For Python: Django is excellent when you need: → authentication → admin tools → ORM → permissions → mature business applications FastAPI is great when you want: → lightweight APIs → async workloads → AI services → simple microservices If you’re building a complex business platform, Django may save months. If you’re exposing a focused AI service, FastAPI may be cleaner. Use the tool that matches the problem. 4. Don’t start with microservices by default This is one mistake I see a lot. A new project does NOT automatically need: → 12 services → Kafka → Kubernetes → service discovery → distributed tracing A modular monolith is often the better starting point. One application. Clear boundaries. Simple deployment. Simple debugging. Then split services later when you have a real reason: → independent scaling → separate team ownership → different deployment cycles → different performance requirements → fault isolation Microservices should solve complexity. Not create it. 5. Start with PostgreSQL unless you have a strong reason not to Most applications need reliable relational data. PostgreSQL gives you: → transactions → indexes → constraints → JSON support → strong tooling → years of maturity You probably don’t need five databases on day one. Add Redis when you actually need caching, queues, or short-lived data. Add a vector database when the product genuinely needs semantic retrieval. Don’t collect infrastructure. Solve problems. 6. Your architecture should match your stage For an early product: Frontend ↓ Backend ↓ PostgreSQL That may be enough. As the system grows, you might add: → Redis → background workers → object storage → queues → search → monitoring → separate services Architecture should evolve with evidence. Not imagination. 7. Optimize for change The first version of your product will probably be wrong. Requirements will change. Users will surprise you. Business rules will evolve. So choose technologies that make change cheap. That often matters more than raw performance. A system that handles 1 million requests per second but takes three weeks to change a form is not necessarily well designed. 8. Use boring technology where possible This is underrated. Boring technology has: → documentation → community support → known failure modes → mature libraries → experienced developers → predictable behavior Your competitive advantage usually isn’t your database. It’s the problem you solve. Save innovation for the parts that actually differentiate the product. If I were starting a typical AI-powered SaaS product today, I’d probably begin with something like: → Python → Django or FastAPI → PostgreSQL → Redis when needed → Docker → React/Next.js for the frontend → A modular monolith → Cloud deployment → LLM APIs only where they create real value Then I’d evolve the architecture as real usage demands it. Not before. The best stack is not the one that looks impressive on an architecture diagram. It’s the one your team can: build, understand, deploy, debug, and change confidently. Technology choices should reduce risk. Not increase ego. What stack would you choose if you were starting a new project today? 👇
2
1
1
3
595
I think one of the biggest traps in software engineering is treating principles like commandments. DRY. SOLID. KISS. YAGNI. Clean Architecture. Microservices. Design patterns. They’re useful. But they can also make code worse when applied without judgment. A few examples: DRY can create the wrong abstraction. Two pieces of code may look similar today but represent different business rules. Combine them too early and now every change requires conditionals, flags, and exceptions. Sometimes a little duplication is cheaper than a bad abstraction. SOLID can become over-engineering. You do not need: → 7 interfaces → 4 factories → 3 adapters → 2 repositories to save one simple object. Abstraction should reduce complexity. If it creates more concepts than the problem itself, something is wrong. Microservices are not automatically “better architecture.” If your team is small and your system is simple, a modular monolith may be easier to build, deploy, debug, and maintain. Distributed systems introduce: → Network failures → Service discovery → Distributed tracing → More deployments → More infrastructure → Data consistency problems You should earn that complexity. YAGNI is easy to understand and hard to practice. Developers love preparing for imaginary futures. “What if we need 10 million users?” “What if we switch databases?” “What if we support 12 providers?” Maybe. But designing for every possible future can destroy the simplicity of the present. Build for real requirements. Let reality justify the next layer of complexity. KISS doesn’t mean write primitive code. It means choose the simplest solution that correctly handles the problem. Simple is not the same as easy. Sometimes getting to a simple design requires more thinking than building a complicated one. And this is why I think engineering judgment matters more than memorizing principles. A junior developer may ask: “Am I following SOLID?” A more experienced developer might ask: “Does this design make the next change safer?” That’s a much better question. Principles are tools. Not goals. The goal is software that is: → understandable → reliable → maintainable → easy to change → appropriate for the problem Sometimes that means introducing an abstraction. Sometimes it means deleting one. Sometimes it means splitting a service. Sometimes it means merging services back together. Sometimes it means following the rule. Sometimes it means knowing exactly why you’re breaking it. That’s the difference between knowing software principles and actually understanding software design. Good engineers know the rules. Great engineers understand the trade-offs behind them. What’s one “best practice” you think developers overuse? 👇
2
2
343