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.

Let's talk about your project

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.

  1. Browser

    A user starts an action.

  2. Server

    The application handles the request.

  3. Database

    A query reads or writes data.

  4. 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.

A system and its connected components

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.

Discuss working together

We reply within one day. Contact us about a project, technical collaboration or hiring. You do not need a finished specification to start the conversation.

You can also email us directly: contact@michalsalek.com