Cloud-Native Architectures Require Specially Skilled Architects

Designing and building a cloud-native application requires special skills and experience beyond the basics required to design and build any software application. Building cloud-native applications requires software architects specially trained in developing these kinds of applications.

Not all applications running in the cloud built and developed by architects need to be cloud-native applications, but all cloud architects need to understand what it takes to build and deploy cloud-native applications. Striving to architect applications so they are cloud-native should be the norm, not the exception. After all, cloud-native application architectures are what the cloud is all about—modern application architectures that are highly scalable, maintain high availability, are highly adaptive and are easy to develop and maintain without being bogged down with high development complexity.

If an application architect ends up building a cloud application but chooses not to use cloud-native technologies, it should be for a good reason.

So, all cloud architects must be skilled in building and architecting modern, cloud-native applications. This means that cloud architects need specialized expertise and experience in building cloud-native applications. In particular, they need experience building and architecting microservices-based applications, container- and Kubernetes-based applications and applications that leverage the services available by public cloud providers.

Let’s look at each of these.

Microservice Architectures

True cloud-native applications are built using microservice architectures. This means they are composed of many smaller services connected together to form larger and more complex applications.

Building a microservices-based application is not simply a matter of taking a monolith and splitting it into multiple pieces. It requires understanding how the functionality of an application can be partitioned in such a way so that the individual components can perform their jobs in isolation without highly interdependent, interservice knowledge.

Strong APIs and service contracts create this isolation. This separation allows large, complex applications to be built using modular, scalable development teams. Understanding why you split an application at a particular location and how individual components cooperate with each other is a core responsibility of the architect.

Containers and Kubernetes

Containers isolate individual microservices from their environment, allowing them to be built and deployed in a variety of environments. When used with Kubernetes, highly dynamic and adaptable microservice architectures can leverage the cloud to create flexible and adaptive applications.

Understanding how containers operate and how Kubernetes is used to operate and connect containers together is critical to the design, construction and operation of a cloud-native application. More than any other technology, Kubernetes—and the underlying container technology it leverages—is critical for all cloud-native applications and requires specialized architectures to create complex infrastructures.

Leveraging Cloud Services

Cloud-native applications make use of the specialized cloud services available in the public cloud. These services—such as scalable database services, data storage, caches, queues and advanced network management—when used with microservice architectures, enable highly adaptive application architectures.

Additional cloud technologies, such as AI and machine learning, further add capabilities to the application’s abilities.

Understanding what cloud services are available and how they work together to make a larger application is a key responsibility of a cloud-native architect. Cloud components aren’t as straightforward as building with children’s blocks; you can’t simply plug them together anyway you want until you get something that looks right. Understanding how cloud services interact together effectively and supportively is essential to building a successful cloud-native architecture.

This process requires a deep understanding of the services within a given cloud provider and how those services work. This is why cloud providers, such as AWS, provide training and certification programs to teach their services and their overall architectural philosophies. These programs, along with architecture programs such as the AWS Well-Architected framework, are helpful programs to teach and drive construction of cloud-native architectures, an essential understanding for any cloud-native architect. Achieving the various certifications offered by the relevant cloud providers is a strong indicator of architectural expertise.

Cloud-Native Architects Need Specialized Knowledge

Modern cloud-native architects require fundamental knowledge not only of how to build large, complex applications but how to structure and deploy them in modern infrastructure frameworks, including cloud-native frameworks. Since the architecture of the application must be designed to leverage the key capabilities of modern infrastructures, having experience and knowledge building, deploying and operating applications in these modern infrastructures is an essential skill for any successful modern software architect.

Lee Atchison

Lee Atchison is an author and recognized thought leader in cloud computing and application modernization with more than three decades of experience, working at modern application organizations such as Amazon, AWS, and New Relic. Lee is widely quoted in many publications and has been a featured speaker across the globe. Lee’s most recent book is Architecting for Scale (O’Reilly Media).

Lee Atchison has 59 posts and counting. See all posts by Lee Atchison