The Devprime platform offers a modern and evolutionary software architecture strategy, based on market practices such as: hexagonal architecture, event-driven architecture, Domain Driven Design and asynchronous communication.
Software developers use the Devprime platform to increase productivity and standardize development across all new projects, accelerating time to market and team scalability by adopting leading technologies and modern software development practices.
By adopting the Devprime platform strategy, it is possible to save weeks of work and achieve a modern project in a matter of seconds. This project is componentized and decoupled, which simplifies the onboarding of new developers and eases the transition between different projects.
The architecture organizes the technological components in the Adapters projects, using accelerators and intelligent behaviors provided by the Devprime Stack. In addition, it separates business behaviors into an isolated project based on Devprime Domain, aiming to simplify maintenance, evolution, and testing.
The following architecture diagram technically demonstrates the technological and standardized separation for all modern microservices projects developed using Devprime technology. In this diagram, you can see the technological components, the business rules, and the unit tests.
The Devprime platform establishes a predictable flow through a modern software architecture, which contributes significantly to developer productivity and architecture governance.
Follow the breakdown of the process flow:
Event Arrival: Events arrive at the microservice from different sources, such as HTTP, gRPC, GraphQL, and Stream requests. These events can represent requests, data updates, notifications, and more.
App Service: Events are directed to an app service, which is responsible for coordinating the process flow. The application service determines how the event should be handled and to which business rule it should be forwarded (Aggregate Root/Domain Services).
Business Rule and Aggregate Root: The Aggregate Root is an essential part of the domain that encapsulates the business logic and maintains the consistency of the related data.
Business Processing: The business rule in an Aggregate Root processes the event according to the application’s specific business logic. This can involve calculations, validations, data updates, and more.
Domain Event Emission: After deal processing, the Aggregate Root emits a domain event. This event notifies you that an important business event has happened in the application.
Event Handler: The Event Handler kicks in to handle the domain event. Within the Event Handler, several actions are performed, including integration with other Adapters:
State: For persisting data in a database, storage, or cache. This ensures that the data is stored securely and durably.
Stream: For emitting events in a queue or topic. This allows other microservices or application components to react to important events.
Services: For communicating with external APIs. This makes it possible to integrate with third-party services such as authentication, sending emails, processing payments, and more.
This predictable and organized process flow approach contributes significantly to maintaining the governance of the architecture. It makes the application easier to understand, test, scale, and maintain, while preserving the isolation of each behavior, for example by separating business rules from the technology layer.
In addition, it allows for greater flexibility and adaptability of the application, as each part of the process can be isolated and replaced independently, facilitating the continuous evolution of the application over time.
Devprime Pipeline is an execution flow orchestrator available in applications based on the Devprime platform. It isolates each process within a context and automatically provides exception handling, observability (log, trace, metrics), and transactional control.
The Devprime platform provides a modern software architecture strategy, and the App project is the initial project of the application, allowing connectivity with other components of the architecture.