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 modern software development technologies and 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 facilitates 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’s technology. In this diagram, you can see the technological components, business rules, and 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 details of the process flow:
Event Arrival: Events arrive at the microservice from different sources, such as HTTP requests, gRPC, GraphQL, and Stream. These events can represent requests, data updates, notifications, and more.
Application Service: Events are directed to an application service, which is responsible for coordinating the flow of processes. The application service determines how the event should be handled and which business rule it should be routed to (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-specific business logic. This can involve calculations, validations, data updates, and more.
Domain Event Emission: After the deal is processed, 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 persistence of 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 communication with external APIs. This makes it possible to integrate with third-party services, such as authentication, sending emails, processing payments, among others.
This predictable and orderly 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 orchestrator of the execution flow 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 design of the application, allowing connectivity with other components of the architecture.