An architectural pattern is a general, reusable solution to a commonly occurring problem in software architecture within a given context. Architectural patterns are similar to software design patterns but have a broader scope.

• Client-Server architectural pattern — Client-server architecture (client/server) is a network architecture in which each computer or process on the network is either a client or a server.
• Layered architectural pattern — Layered Architecture is commonly using when design J2EE application - it is something like defacto standard and widely known by most architects, designers, and developers. The layered architecture pattern closely matches the traditional IT communication and organizational structures found in most companies, making it a natural choice for most business application development efforts. 
• Master-Slave architectural pattern — Master/slave is a model of communication where one device or process has unidirectional control over one or more other devices. In some systems a master is selected from a group of eligible devices, with the other devices acting in the role of slaves.
• Pipe-filter architectural patterns - useful approach for analytics based on daisy chain — A very simple, yet powerful architecture, that is also very robust. It consists of any number of components (filters) that transform or filter data, before passing it on via connectors (pipes) to other components. The filters are all working at the same time. The architecture is often used as a simple sequence, but it may also be used for very complex structures.
• Broker architectural pattern - usually used in Message Middlewares like Apache ActiveMQ, Apache Kafka, RabbitMQ — The Broker architectural pattern can be used to structure distributed software systems with decoupled components that interact by remote service invocations.
• Peer-to-peer architectural pattern - usually used in file sharing like BitTorrent or multimedia protocols like P2PTV or PDTP — Peer-to-peer architectural pattern (P2P architecture) is a commonly used computer networking architecture in which each workstation, or node, has the same capabilities and responsibilities. It is often compared and contrasted to the classic client/server architecture, in which some computers are dedicated to serving others.
• Event-bus archiectural pattern - used in Android app development and Push Notification Service — Event-bus architecture pattern is a distributed asynchronous architecture pattern to create highly scalable reactive applications. The pattern suits for every level application stack from small to complex ones. The main idea is delivering and processing events asynchronously.
• MVC(Model-view-controller) architectural pattern - used in web application development like Django and Rails — MVC(Model–view–controller) is an architectural pattern commonly used for developing user interfaces that divides an application into three interconnected parts. This is done to separate internal representations of information from the ways information is presented to and accepted from the user. The MVC design pattern decouples these major components allowing for efficient code reuse and parallel development.
• Blackboard architectural pattern - used in NLU(Natural Language Understanding) and car recognition — Blackboard architectural pattern usually used in Artificial Intelligence Software to implement Non-Deterministic Algorithm.
• Interpreter architectural pattern - used in database query language such as SQL — This pattern is used for designing a component that interprets programs written in a dedicated language. It mainly specifies how to evaluate lines of programs, known as sentences or expressions written in a particular language. The basic idea is to have a class for each symbol of the language.
• Microservice architectural pattern aka MSA - one of the trends of service architecture in 2018- — MSA (Microservice architecture), or simply microservices, is a kind of methodology to develop service by divide and conquer - a distinctive method of developing software systems that tries to focus on building single-function modules with well-defined interfaces and operations. The trend has grown popular in recent years as Enterprises look to become more Agile and move towards a DevOps and continuous testing. Microservices can help create scalable, testable software that can be delivered weekly
• Active-Active / Active-Stand-by Architectural Pattern — Active-Active / Active-Stand-by architectural patterns are commonly used when we consider fail-over in server deployment design.