Most software projects move fast in their first year. The trouble usually shows up in years two and three: a change that should take a week takes a month, a small failure takes down the whole service, and replacing a single vendor turns into a multi-month project. Most of that pain traces back to software architecture, to a handful of early decisions that looked small at the time.
This article is for managers who are about to build software or hand its development to another team. The examples come from real projects delivered by the Dropp engineering team, not from a textbook.
What is software architecture?
Software architecture is the fundamental structure of a system: what parts it is made of, how those parts communicate with each other and with the outside world, and which principles guide how it is built and changed. The ISO/IEC/IEEE 42010 standard uses the term the same way: the fundamental concepts of a system, expressed in its elements, their relationships, and the principles of its evolution.
For a manager, a more practical definition helps: architecture is the set of decisions that are hard and expensive to change later. Martin Fowler describes architecture in similar terms, as the important things you wish you had got right early. Button colors are not architecture. The data model, the boundaries between parts of the system, and the way you depend on external services are.
Why architecture is a management concern, not just an engineering one
Every architecture decision is ultimately a business trade-off: speed today against flexibility tomorrow, or build cost against running cost. Four things managers care about depend directly on it:
- Delivery speed: can a new feature be added without touching half the system?
- Cost of ownership: how many servers, services and specialist skills does it take to keep the system running?
- Operational risk: how much of the service goes down when one part fails?
- Dependency: what happens if a vendor, a cloud provider or a key person disappears? Where sanctions or regional restrictions apply, access can be cut overnight, which makes this question more serious than it looks.
Seven decisions that get expensive later
These seven decisions are made in every custom software development project, deliberately or by accident. Each comes with one question a manager can ask the team, even without deep technical knowledge.
1. The data model, and where critical rules are enforced
Code can be rewritten. Moving years of data is a different matter. The choice of database and the shape of the data are the longest-lived architecture decisions you will make.
In ParsChart, a financial market data platform, every asset class has its own fields: gold, coins, crypto and listed equities. That is why a document database (MongoDB) was chosen. But more flexibility means fewer guarantees, so two things were done alongside it. Wherever money moves, operations run inside a transaction. Critical business rules are locked into the database itself: the rule "one open invoice per phone number" is enforced by a unique index, not by developer discipline alone. Every schema change is applied through a versioned migration script.
The question to ask: which three rules would cost us money or trust if they were broken, and where exactly are they enforced?
2. System boundaries: modular monolith or microservices
This is the most debated architecture decision, and the right answer has nothing to do with fashion. Across our own projects, two different answers have both been correct.
- ParsChart: one application, more than 40 modules. The whole backend is built and deployed as one unit, but internally it is split into modules with clear boundaries, such as users, markets, portfolios, payments and subscriptions. The project's architecture document explicitly says microservices and other complex patterns should not be introduced without a concrete need. One small team, one database and one deployment pipeline were enough for this product.
- TheRiskPilot: a single core, two separate services. Product logic stayed in one application. Only two general-purpose capabilities were split out: identity and access, and email delivery. Both are useful to any product, and separating them cost little.
- Hypernyx: microservices. The system had several services whose load and rate of code change differed widely, and one of them controlled hardware and was highly sensitive. Splitting the services let each one scale and ship independently, and kept a failure in one part away from the sensitive service.
Microservices pay off when the parts of a system genuinely have different needs. The price is operational: deployment, monitoring and debugging multiply. A modular monolith is not free either. Everything scales together, and module boundaries hold only as long as the team stays disciplined. A module that grows too large becomes a small monolith of its own.
The question to ask: which part of the system truly needs to scale or ship on its own? If the answer is "none", it is too early for microservices.
3. A wall between your system and external vendors
Payment gateways, SMS, email, file storage and data providers all get replaced sooner or later. Prices rise, quality drops, and sometimes access simply disappears. If a vendor's name and details are scattered across the codebase, every switch becomes a full project.
In ParsChart, every external dependency sits behind a fixed contract, and the benefit has already been proven in practice: the payment gateway was replaced without touching subscription or invoicing logic. Email can be switched between two providers with a single setting. There is also a "market simulation mode" that returns synthetic data during development and testing instead of calling a paid API.
To be honest about the limits: this wall lowers the cost of replacing a vendor, but it does not remove the dependency itself. If all your data comes from one provider, losing that provider is still a serious problem. The same logic applies to cloud hosting; we cover the trade-offs between cloud, multi-cloud and on-premise in Cloud & On-premise Infrastructure.
The question to ask: if we had to replace our payment gateway or SMS provider tomorrow, how many parts of the system would change? Ask the same about connections to your other internal systems, which is the subject of enterprise integration.
4. Keep heavy work off the user's path
Users should not wait for an external service to respond or for a heavy calculation to finish. In ParsChart, price ingestion, statistics and chart calculations, SMS delivery and alert checks run in 8 background queues. Gold and coin prices are refreshed every minute, but only during market hours (09:00 to 17:00), so nothing is spent on the paid API outside those hours. Here an architecture decision has a direct effect on the monthly bill.
In TheRiskPilot, every report passes through several separate stages, each with its own queue. Large reports and short news items are processed on two separate lanes, so a big report never delays breaking news.
The price of this decision is operational complexity: retrying failed jobs, preventing duplicate work, and monitoring the queues. A queue that nobody watches can fill up silently without raising a single error.
The question to ask: if an external service slows down, do our users feel it too? And if a queue stops, who finds out?
5. AI recommends, code decides
A few years ago this decision was not on the list. Today, any product that uses a language model has to make clear how much authority the model's output has.
In TheRiskPilot, the language model only produces scores and recommendations. The final decision to publish is made by code, using explicit thresholds. The result is predictable behavior that can be tested and reviewed. Cost is controlled in the architecture as well: a switch that pauses processing without a redeploy, a cap on the number of requests, and token usage recorded for every analysis.
The question to ask: if the model is wrong, what stops that error from reaching a customer? And if the API bill suddenly grows tenfold, how do we stop it?
6. Identity, access and security in the core, not in every feature
Adding roles and permissions to a system that was built without them means reviewing every page and every service. It is one of the most expensive late fixes there is.
ParsChart was built on a shared internal core that provided authentication, roles, logging and a consistent response format from day one. Security controls apply to every request in one place: role-based access with fine-grained permissions, two-factor authentication and rate limiting. A developer building a new feature does not write security logic; they only declare who is allowed in.
The price of a shared core is that the product is tied to the core's decisions. The payoff arrives with the second and third product: repetitive work is written once, and the team goes straight to business logic.
The question to ask: if a developer forgets to define access for a new page, is that page closed or open? The right answer is "closed".
7. Observability and quality gates from day one
This is the only decision on the list that is cheap at the start and expensive later. In ParsChart, error tracking with Sentry and structured logging were added on the second day of the project. Environment settings and all secrets are kept outside the code.
Every change passes through an automated pipeline (CI/CD) before it reaches users: unit tests, integration tests against a real database and cache (41 suites with roughly 730 scenarios), code quality checks with SonarQube and security scanning with Trivy. A database backup is taken before every schema change.
There is also a management detail in this pipeline: in an emergency there is a way to skip the tests, but it requires a recorded reason and the team is notified the moment it is used. The shortcut exists, but it is never silent.
The question to ask: if the service fails tonight, do we find out first, or does a customer? And what stops broken code from reaching production?
Types of software architecture, in management terms
No style is better by default. Each one solves a specific problem and carries a specific cost, and most real systems combine several of them.
| Architecture style | When it fits | Hidden cost |
|---|---|---|
| Layered (traditional) | Simple business systems and small teams | As the product grows, boundaries between business areas blur |
| Modular monolith | Most products in their first few years, with one team | Everything scales together; boundaries depend on team discipline |
| Microservices | Parts with different load, rate of change or sensitivity, and several independent teams | Deployment, monitoring and debugging multiply; needs a serious DevOps capability |
| Event-driven | Several parts must react to one event, such as a successful payment | Tracing an event's path is harder; events that are not persisted can be lost |
| Serverless | Short, sporadic jobs with irregular traffic | Strong lock-in to one cloud provider; availability varies by region |
Decisions you do not need to make today
Over-thinking reversible decisions is as costly as getting irreversible ones wrong. A team that spends its first month choosing tools is often avoiding the decisions that matter. These can safely wait:
- Splitting out services: if modules have clear boundaries, any one of them can be extracted when a real need appears.
- Cache and queue tooling: behind a well-defined layer, swapping them is contained.
- Orchestration tools such as Kubernetes: usually unnecessary for a first version. Standard container packaging keeps the door open.
- Visual details and the UI framework: with a stable API contract, the frontend can change independently.
All of these depend on one condition: boundaries and contracts drawn correctly from the start. Reversibility is itself the result of an architecture decision.
Write architecture decisions down, with numbers
A decision that is not written down disappears with the first person who leaves the team. The next person either changes it without knowing why it was made, or never dares to touch it. At Dropp, every architecture decision is recorded as a short document (an ADR) in our internal documentation system, Outline: the context, the decision, the options we rejected, and the price we accepted.
The best ADRs state trade-offs as numbers. In ParsChart, high-traffic pages are pre-computed and the rule is explicit: each cache lives for 30 minutes and is rebuilt every 15 minutes, so a single failed run never leaves a page empty. Data retention also follows value: raw prices for 7 days, hourly prices for 180 days, and daily candles forever. Numbers like these end debates about taste. The manager knows users may see data that is a few minutes old, and has accepted that knowingly in exchange for a stable service.
A manager's checklist before the project starts
Ask these questions of your internal team or your engineering partner. If the answer to any of them is "we'll decide later", that decision has not been made yet.
- What are the critical business rules, and where in the system are they enforced?
- Why this architecture style? What would have to change for you to change your mind?
- What happens if any of our external vendors disappears tomorrow?
- Which work runs in the background, and who monitors it?
- If the product uses AI, does the model make the final call, or an explicit rule? Where is the cost ceiling?
- Is access closed or open by default?
- Where are errors recorded, and who gets alerted?
- What stops untested code from reaching production?
- Where are architecture decisions recorded, and can I read them?
Conclusion
Good architecture means getting a few irreversible decisions right and keeping the rest reversible. Managers do not need the technical details. They need to know which decisions deserve attention and which questions to ask.
If you are about to start a project, or you run a system where every change has become expensive, the Dropp engineering team can review its architecture with you as your engineering partner. You can find more on our software design and development services page.
Frequently asked questions
What is software architecture?
It is the fundamental structure of a software system: its parts, how those parts relate to each other and to external systems, and the principles that guide how it is built and changed. Put simply, architecture is the set of decisions that are hard to change later.
What is the difference between software architecture and software design?
Architecture deals with boundaries and high-level decisions that affect the whole system. Software design deals with the internal structure of each part, and changes to it are usually more local and cheaper.
When do we need a software architect?
When the product handles money, sensitive data or integrations with several other systems, or when it will be maintained for years. The role does not have to be a full-time hire; what matters is that someone owns the high-stakes decisions.
Can the architecture be changed later?
Yes, but at a cost. It is usually better to rebuild the system step by step than to rewrite it all at once. That is the subject of software modernization.