Software architecture
We design the structure of new applications and clarify dependencies in existing systems. We define module boundaries, data flows and release practices. Decisions follow the project requirements and account for ongoing maintenance.
Conditions and design decisions
When designing or extending an application, we start with its users, processes and constraints. We establish which data it handles, who can access it and which tools it must work with. In an existing system, we also examine dependencies that could make a change difficult.
We consider performance across the complete flow: browser interactions, server requests, and data reads and writes. We agree on the most important scenarios and how to check them. Measurements help establish whether the problem is a large response, a database query or lengthy processing.
The outputs are decisions needed for delivery: responsibility boundaries, data flows, access requirements and acceptance criteria. We develop the architecture as part of building or extending an application or system, accounting for deployment and ongoing maintenance.
Where to look for delay
Example flow for performance measurement.
- Browser
A user starts an action.
- Server
The application handles the request.
- Database
A query reads or writes data.
- Measurement
Timings help locate the delay.
Boundaries of responsibility
A module groups related rules and data, such as order handling or payments. We define its responsibilities and how other parts can use it. We share reusable elements where they genuinely follow the same rules.
For example, in a booking system, a time slot may need immediate confirmation while a notification can be sent later. Separating those tasks allows the notification to be retried without creating the booking again. Error handling and the status shown to the user also need to be defined.
Domain-Driven Design helps organise complex business rules. CQRS separates commands that change data from queries that read it. We use these approaches when they solve a specific problem; a simple application does not need the full set. We consider scaling a module independently when its workload justifies it, taking maintenance costs into account.
Booking and notification
Separating the tasks allows a notification retry without creating another booking.
- Booking confirmation
- The time slot may require immediate confirmation.
- Notification
- The message can be sent later and retried.
- Status and errors
- We agree error handling and the status shown to the user.
Decisions and change history
We document important decisions, dependencies and how to run the application. Handover documentation covers the agreed scope: environment configuration, deployment, tests and handling common failures. This helps the next person check how the system works and prepare a change.
When an operation history is needed, we establish which changes to record, their timestamps and their connection to the relevant process. This record helps explain a claim or a status change. Keeping a history does not automatically require an architecture that reconstructs the entire state from events.
We test key rules and flows, then use the agreed monitoring after deployment. Our fullstack page explains the tools in more detail. Technology should support the requirements, while documentation should also explain the limitations of the chosen solution.