Our approach
From architecture to operation.
Vianmax™ approaches complex technology problems as systems: understanding the problem, designing the architecture, engineering the platform, validating the result and operating what is built.
Discover Architect Build Validate Operate
The engineering lifecycle
Five phases, one system.
Our approach is structured around five phases. Each one produces something the next phase depends on, and a set of concerns runs through all of them.
01
Discover
Understand the problem
- Objectives and constraints
- Workflows and existing systems
- System context
02
Architect
Design the system
- Boundaries and data flows
- Security and failure handling
- Deployment and recovery
03
Build
Engineer the product
- Modular implementation
- Contracts and data models
- Review and documentation
04
Validate
Test the assumptions
- Functional and integration
- Failure handling
- Data integrity
05
Operate
Run and improve the system
- Monitoring and logging
- Recovery and maintenance
- Continuous improvement
- Security
- Data integrity
- Observability
- Auditability
- Documentation
Why an approach
Complex problems need more than code.
Software projects rarely fail because code could not be written. More often the problem was misunderstood, the architecture was rushed, assumptions were never tested, or operational realities were considered too late.
Vianmax™ treats software as a system. Before implementation is treated as complete, the parts around it are considered too. The approach does not remove every risk; it makes risks visible early, while they are still inexpensive to address.
- Business context
- Architecture
- Data
- Security
- Integration
- Failure modes
- User experience
- Operations
= a platform that can be trusted to run
- 01Discover
- 02Architect
- 03Build
- 04Validate
- 05Operate
01 · Discover
Understand the problem before designing the solution.
We begin by understanding what the system must accomplish, who depends on it, what already exists and where the real constraints lie.
Discovery establishes
- Business objectives
- User workflows
- Operational constraints
- Existing systems
- Data sources
- Integration requirements
- Regulatory or domain considerations
- Technical constraints
- Measurable outcomes
Typical activities include stakeholder interviews, workflow mapping and a technical review of existing systems.
Figure 1 · From business to system context
- BusinessWhat the system must accomplish
- UsersWho depends on it
- WorkflowsHow work actually happens
- ConstraintsRegulatory, operational and technical limits
- RequirementsWhat must be true for it to succeed
- System contextWhere it sits among existing systems
- 01Discover
- 02Architect
- 03Build
- 04Validate
- 05Operate
02 · Architect
Design the system before scaling the implementation.
Architecture establishes how the major parts of the system interact: where the boundaries are, how data moves, what is trusted, and what happens when something fails.
Figure 2 · A layered view of a system
Users
Application
Services
Data
Integrations
Infrastructure
- Application boundaries
- APIs
- Data flows
- Databases
- Integrations
- Authentication
- Authorisation
- Security
- Scalability
- Observability
- Failure handling
- Deployment
- Recovery
A generic, logical view. Each engagement’s architecture is designed for its own requirements; see No two systems are identical.
Principle
Architecture before code.
Explore Technology & SecurityGood software is not defined only by what it does when everything works. Its architecture must also account for what happens when dependencies fail, data is incomplete, users behave unexpectedly or systems need to evolve.
- 01Discover
- 02Architect
- 03Build
- 04Validate
- 05Operate
03 · Build
Turn the architecture into maintainable software.
Implementation follows the architecture: modules with clear responsibilities, contracts between them, and code that someone other than its author can understand and change.
What the build covers
- Modular implementation
- Reusable components
- API contracts
- Data models
- Frontend systems
- Backend services
- Integrations
- Testing
- Version control
- Documentation
- Code review
How it is delivered
Where appropriate, engineering workflows include short iterative cycles with regular demonstrations, code review and continuous integration, with source kept in a shared repository.
Progress is visible as working software at each milestone, not only as status reports.
Product engineering
Engineering the product, not just the software.
Features are only part of a product. Vianmax™ works on product, experience, architecture, data, security and operations as one system, which is also how we build our own products.
- Product
- UX
- Architecture
- Data
- Security
- Operations
- 01Discover
- 02Architect
- 03Build
- 04Validate
- 05Operate
04 · Validate
Test the assumptions before trusting the system.
Validation checks the system against what it was meant to do, and against the conditions it will meet in operation. The dimensions that matter depend on the system.
- 01FunctionalDoes it do what was specified?
- 02SecurityDoes it resist misuse and enforce access?
- 03IntegrationDo the parts and third parties agree?
- 04PerformanceDoes it respond acceptably under expected load?
- 05ReliabilityDoes it keep working as conditions change?
- 06UsabilityCan people complete their work with it?
- 07Data integrityIs what is stored correct and consistent?
- 08Failure handlingDoes it fail safely and recover?
Figure 3 · The validation loop
- 01Expected behaviourWhat should happen
- 02TestExercise the system
- 03ObserveWhat actually happens
- 04Identify gapWhere the two differ
- 05CorrectChange the system
- 06RetestConfirm the change
Retest leads back to expected behaviour until the gap is closed.
For critical systems, validation can include a parallel run before cut-over. No certification, formal test result or reliability figure is implied.
Failure modes
Designing for what can go wrong.
Every system meets conditions its happy path did not expect. The design question is not whether they will occur but how the system behaves when they do. These are design principles, not guarantees.
| What can go wrong | How the design responds |
|---|---|
| API failure or service timeout | Stop and report rather than guess; retry only when it is safe to |
| Network interruption | Detect the loss and hold state until the connection is confirmed |
| Stale data | Check freshness before acting on it |
| Authentication expiry | Fail closed and ask the user to re-authenticate |
| Duplicate requests | Design operations so a repeat does not act twice |
| Unexpected user input | Validate at the boundary, before it reaches domain logic |
| Broker or third-party rejection | Surface the rejection and its reason to the user |
| Partial execution | Reconcile against the system of record before continuing |
| Database failure | Recover according to a documented procedure |
| Deployment problems | Release deliberately, with a way back |
Why confirmed status matters
In AlphaSync, any resubmission is designed to follow a confirmed order status, never a timeout alone, and positions are designed to be checked against broker-reported state. An audit trail and observability make each step traceable.
AlphaSync architectureWhy checks come before execution
The Max Algos platform places pre-trade risk controls, such as market-hours, funds and price-band checks, in front of automated execution, with monitoring and a trade log after it.
Max Algos case study- 01Discover
- 02Architect
- 03Build
- 04Validate
- 05Operate
05 · Operate
A platform is not finished when it is deployed.
Once a system is live, the questions change: is it healthy, is it being used as expected, what is failing quietly, and what should change next.
Deployment is the beginning of an operational lifecycle, not the end of engineering.
Operational considerations
- Monitoring
- Logging
- Observability
- Alerts
- Deployment
- Backups
- Recovery
- Maintenance
- Incident response
- Performance monitoring
- Continuous improvement
Typical outputs include runbooks, documentation, handover and a support plan. How we protect and run systems in operation is set out in Technology & Security.
Figure 4 · The closed loop
- 01Discover
- 02Architect
- 03Build
- 04Validate
- 05Operate
- 06Learn
- 07Improve
Improve feeds back into Discover.
Domain-aware engineering
Engineering changes with the domain.
The phases stay the same; what they must pay attention to does not. Engineering principles remain consistent; implementation changes with the problem.
FinTech
- Market data
- Execution
- Risk
- Auditability
- Broker integrations
AI
- Context
- Data
- Human oversight
- Evaluation
- Responsible deployment
EdTech
- Learning workflows
- Content
- Assessment
- AI assistance
- Faculty interaction
Enterprise
- Business workflows
- Integration
- Identity
- Data
- Operational continuity
Evidence
The approach in practice.
Three systems where the approach can be seen: one of our own products and two client platforms. Each page describes what was built and, where relevant, what is still in development.
AlphaSync
FinTech · Trading technology
- Market data
- Strategy
- Risk
- Execution
- Analytics
Max Algos
FinTech · Algorithmic execution
- Strategy creation
- Broker connectivity
- Execution
- Risk controls
- Monitoring
Gnanasooriyan Academy of Arts
EdTech · AI · Creative technology
- Learning platform
- AI tutor
- Interactive classroom
- Portfolio
- Community
Principle
No two systems are identical.
Vianmax™ does not force every project into the same architecture. A monolith can be the right answer; so can a set of services. What decides it is the problem.
The objective is not to use the most complicated architecture. It is to use the architecture appropriate to the problem.
- Business requirements
- Scale
- Data
- Integrations
- Security
- Latency
- Operational environment
- User workflows
- Domain constraints
Responsible engineering
Engineering with consequences in mind.
Our line is “Engineered for consequence.” In practice it means asking what happens to the people and organisations who depend on a system when it behaves correctly, and when it does not.
- 01SecurityControls designed into each layer rather than added afterwards.
- 02PrivacyKeep only what is needed; protect what is kept.
- 03AuditabilityRecord who did what, and when.
- 04Data integrityDecisions are only as good as the state they act on.
- 05Responsible AIAI output is designed to be checked, with limits stated.
- 06Human oversightPeople stay responsible for consequential decisions.
- 07Operational resiliencePlan for failure and recovery before they are needed.
Transparency
Clear about what is built.
Our products and client platforms are at different stages, and a single platform can contain capabilities at several of them. Vianmax™ labels these distinctions rather than presenting planned functionality as completed.
The same labels appear on our product and case-study pages, so a reader can always tell what exists from what is intended.
- 01ProductionIn use todayAlphaSync
- 02DevelopedBuilt and demonstrated, not yet releasedGnanasooriyan Academy platform, Phase 1
- 03In developmentBeing builtAlphaSync Campus, HedgePro
- 04Target architectureThe designed direction, not deployedHedgePro architecture preview
- 05RoadmapFuture possibilities, not commitmentsStated as possibilities only
What the process produces
Outputs you can keep.
Depending on the engagement, engineering outputs may include the items below. Documentation produced for a client engagement is the client’s to keep.
| Phase | Engineering outputs | Typically handed over |
|---|---|---|
| Discover | Requirements | Requirements specification |
| Architect | Architecture · API contracts · Data models · UI/UX · Security design | Architecture document and a clickable prototype for sign-off |
| Build | Implementation | Working software at each milestone; source in a shared repository |
| Validate | Testing | Test results and a release checklist |
| Operate | Documentation · Deployment · Monitoring | Runbooks, documentation and a support plan |
Engagement
From problem definition to platform operation.
For a client, the lifecycle reads as four stages. Three engagement models fit different needs.
- 01UnderstandDefine the problem and constraints.
- 02DesignCreate the system architecture and product direction.
- 03EngineerBuild and integrate the platform.
- 04OperateDeploy, observe and evolve the system.
- Project deliveryA defined scope delivered through the five phases, with milestones agreed after discovery.
- Ongoing developmentA continuing engagement for products that evolve, with a stable team and a shared roadmap.
- Technical advisoryArchitecture reviews, system audits and guidance for internal teams, particularly in trading technology.
Technology & Security
Architecture is only one part of a reliable system.
Explore how Vianmax™ approaches the rest of it:
- Security
- Data protection
- Identity
- Auditability
- Observability
- Resilience
Solutions
Different problems. Different systems. One engineering discipline.
Have a complex system to build?
Whether the challenge is a new product, an AI-enabled workflow, a financial technology platform or a learning system, Vianmax™ approaches the problem from architecture through operation.