Architecture that holds at 1M users.
We design for the scale you are heading toward, not just the scale you are at today. Every system we build is observable, resilient, and structured to evolve without being rewritten from scratch when your user base grows.
Architecture principles we ship by.
These are not aspirational. They are constraints that every architecture decision at Meraki must satisfy before we consider it acceptable.
Separation of concerns
Every component has one job. Presentation logic never touches data access. Business rules live in a dedicated layer, not inside controllers or database triggers. Clean boundaries make systems testable, changeable, and understandable.
Defence in depth
Security is not a single gate â€" it is a series of independent layers. We apply authentication, authorisation, input validation, rate-limiting, and network segmentation at every tier so that a breach of one layer does not mean a breach of all.
Observable by default
A system you cannot observe is a system you cannot trust. Structured logging, distributed tracing, and application metrics are configured from day one â€" not retrofitted after an incident. You should always know what your system is doing.
Stateless where possible
Stateless services scale horizontally without coordination overhead. Session state belongs in a cache, not in memory. When we do need shared state, we are explicit about where it lives and who owns it.
Data integrity first
Constraints belong in the database, not just in application code. Foreign keys, unique constraints, and check constraints are the last line of defence against corrupt data â€" and they should be treated as such.
Fail gracefully
Every external dependency â€" third-party APIs, message queues, caches â€" can fail. We design with circuit breakers, timeouts, fallback behaviours, and retry logic so that a dependency failure degrades functionality rather than taking the whole system down.
Reference architecture.
A production-grade layered architecture adapted to your specific context. Each layer is independently deployable, horizontally scalable, and replaceable without rewriting adjacent layers.
Each engagement is adapted from this reference. Not all layers are required for every project â€" we scope what is necessary, nothing more.
Technology choices we make and why.
We have strong opinions about tooling â€" and we document the reasoning behind every choice so your team can challenge them or understand them when we are gone.
When we do architecture reviews.
Architecture reviews are not a luxury â€" they are the cheapest form of insurance available in software development. We offer three structured review engagements.
Greenfield project
FoundationPre-buildBefore a single line of code is written, we run a two-day architecture sprint. We map requirements to system boundaries, identify the highest-risk technical decisions, choose the right data models, and produce an architecture decision record (ADR) your whole team can reference throughout the build. Starting right is exponentially cheaper than refactoring later.
Inherited codebase
AuditOn acquisition or team changeJoining an existing system without understanding its structure is how debt accumulates silently. We conduct a structured codebase audit â€" reviewing architecture decisions, data models, dependency health, test coverage, and security posture â€" and produce a prioritised remediation plan. You will know exactly what you have, what needs fixing, and in what order.
Pre-scale audit
ScaleBefore launch or growth campaignArchitecture that works at 1,000 users often collapses at 100,000. Before a growth push, funding round, or viral moment, we profile your system under simulated load, identify the bottlenecks that will cause problems, and redesign the components most likely to fail. Better to find the breaking points in a test environment than in production.
Let's design your architecture together.
Whether you are starting from scratch or trying to understand what you have inherited, we will give you a clear picture of the path forward â€" backed by experience building systems that have survived real-world scale.