The problem behind a simple app
Appreciate is a digital investment platform that aims to make stock market investing simpler for individuals. Users get market data, portfolio management and investment tracking through web and mobile applications.
Individual investors want three things to be easy: seeing current market data, keeping track of several investments, and placing trades. Each of those depends on systems that are not simple. Data arrives continuously, several financial APIs have to be integrated, and activity can rise sharply when markets move.
A single application handling all of that would be hard to scale and harder to change. The platform needed a backend that could run asynchronous work reliably and grow with its users.
What we knew before we built
No before-and-after baseline is published for this project, so this page does not offer an improvement figure. What can be stated is what the backend had to support.
- 5
- Objectives, from real-time data to modular, maintainable services
- 2
- Surfaces to serve from one backend: web and mobile
- 3
- Environments to deploy to consistently: development, staging and production
That set three requirements for the work. Continuous market data could not be allowed to hold up requests from users. APIs for portfolios and trading had to be secure and able to scale. And the infrastructure had to stay available as activity grew.
The approach we chose
We separated the platform's functions into independent Python services, so that each can be developed and maintained on its own, and moved slower work out of the request path:
- Microservices. Independent services built with Flask and Django, in place of one large application.
- Asynchronous workers. Background tasks handle real-time updates and notifications.
- REST APIs. Django REST Framework provides the interface for trading operations, portfolios and data retrieval.
- Managed cloud infrastructure. AWS provides compute, storage and a managed database, with services packaged in Docker.
A market update moves through four stages:
- Receive. Data arrives from market data feeds and financial APIs.
- Process. Background workers handle it asynchronously, so that API requests are not held up.
- Store. Results are written to PostgreSQL schemas designed for efficient reads and writes.
- Serve. REST APIs give web and mobile apps the updated data, and notifications go out to users.
What we built
Our main contribution was the backend and its infrastructure: asynchronous processing, APIs, services, database design and cloud deployment.
Asynchronous processing
We designed and implemented asynchronous tasks for real-time stock updates and notifications, using Python and Django REST Framework.
Secure REST APIs
REST APIs were built to handle trading operations, portfolio management and data retrieval, and to scale with the number of users.
Independent microservices
Platform functions were separated into independent services using Flask and Django, which allows modular development and easier maintenance.
AWS infrastructure
Cloud infrastructure uses EC2 for compute, S3 for storage and RDS for a managed database, with availability and scalability as the design goals.
PostgreSQL design and Docker deployment
PostgreSQL schemas were designed and optimized for efficient storage and retrieval. Docker packages each microservice for consistent deployment across development, staging and production, with CI/CD pipelines supporting releases.
Market data never stops arriving, so it should never be what makes a user wait.
The guardrails around the platform
Portfolio and trading data deserve careful handling, and users notice quickly when a system falls behind. These decisions were part of the architecture from the start.
- Secure APIs. Trading and portfolio operations go through APIs built with security as a stated objective.
- Isolated services. Independent microservices limit how far a change in one function reaches into the others.
- Work kept off the request path. Background workers carry continuous data processing, which protects API responsiveness.
- Consistent deployments. Docker and CI/CD keep what runs in development, staging and production aligned.
- A clear view of compliance. Regulatory obligations belong to the business and its licensed entities. We do not describe an architecture as compliant in itself.
What was reported
The project delivered an investment platform backend with real-time market tracking for web and mobile users. The effects below are what the project team reported; none of them is a measured result:
- Performance. The platform was reported to perform well while tracking the market in real time. No latency or throughput figures are published here.
- Architecture. The modular backend is designed to support future growth and new features.
- Reliability. Portfolio and trading management were reported to be secure and reliable for web and mobile users.
What stays hard
Three challenges shaped this work, and any team building a platform like this should plan for them. Each came with a specific solution.
- Handling real-time data. Continuous stock market feeds cannot be allowed to cause delays. We used asynchronous tasks and background workers to process them efficiently.
- Scalable API architecture. APIs have to support many users and heavy volumes of trading requests. We adopted a microservices architecture with load balancing and optimized query performance.
- Cloud integration. Several AWS services have to work together reliably. We followed AWS best practices, with auto-scaling, S3 for storage and RDS for managed databases.