Many companies today are innovating rapidly with digital products in order to compete in a world of new technologies. Modern applications are the key to increasing developer agility alongside the reliability, security and scalability of those applications.
In building modern applications you may need to reconsider your application's architectural patterns, its operating model and its software delivery process.
This is a powerful approach to designing, building and managing software in the cloud.
Below are the seven characteristics of modern applications.
A culture of ownership.
Architectural patterns: microservices.
Compute for modern applications: containers and AWS Lambda.
Data management: purpose-built databases.
CI/CD release pipeline: standardised and automated.
Operating model: as serverless as possible.
Security: everyone's responsibility.
Building a culture of ownership
It all starts when we make it possible for our people to deliver better outcomes for customers. For that we use the idea of 'products, not projects'. It means the teams that create the products are responsible for running and maintaining them, so they are responsible for the whole product and not only for one part of it. When we give teams complete control of the lifecycle — including customer feedback, roadmap planning, and developing and operating the application — they become owners and are empowered to create and deliver new results.
Autonomy creates motivation, opens the door to creativity and develops a culture of taking risks in an environment of trust. Empowering teams to own the product changes an organisation's mindset, the team structure and the work they take responsibility for.
Architectural patterns: microservices
You can build a good culture of ownership in your organisation and still have trouble scaling if the application architecture has dependencies that stop teams owning the end product. That is why it is advisable to build a microservices architecture for applications that change and grow quickly.
Microservices are the architectural expression of a culture of ownership. They split complex applications into components that a single team can own and run independently. With a monolithic application there can be problems when several developers push changes at the same time, which creates friction at various points in the lifecycle. All of that means coordinating changes in advance to make sure you are not affecting another developer's code. If you need to update a key library, you have to convince everyone else to update at the same time — and that can be very hard.
With a microservices architecture, an application is made of several independent components that run each application process as a service. When a service is running independently and is managed by a single team, each service can be updated, released and scaled to meet demand for specific application functions. A shopping cart, for example, may be used by many users during a sale. Microservices communicate data between themselves through defined interfaces, using lightweight APIs, events or streams.
More and more developers are relying on event-driven architectures — ones where actions are triggered in response to changes in data — to improve an application's scalability and resilience while reducing costs.
Compute for modern applications: containers and AWS Lambda
Instances are no longer the only option on AWS. Modern applications now use containers, or event-based serverless functions running on AWS Lambda. Choosing between instances, containers and Lambda comes down to how much flexibility a company needs versus how much simplicity.
Containers have become the most popular way of packaging code, which makes them an excellent way of modernising older applications. Containers offer excellent portability and flexibility over how applications are configured.
Lambda, on the other hand, offers greater simplicity so you can write code strictly for the business logic, and it lets you take advantage of the greater agility the cloud can offer.
Data management: purpose-built databases
The shift to a microservices architecture has a big impact on how we store and manage data. If every microservice is talking to a monolithic database, then the database is still a point of failure. That is why modern applications are built with decoupled data stores, each of which is part of a single microservice.
It is not practical for one database to meet the specific needs of a set of several microservices. By decoupling the data along with the microservices, teams are free to choose the database that best fits the task at hand. If the application needs data about items that change over time, for example, it can choose a time-series database such as Amazon Timestream; or if it needs to keep a cryptographically verifiable record of transactions, Amazon Quantum Ledger Database would be a good option. Generally, the best database is the one that does exactly what the microservice needs.
CI/CD release pipeline: standardised and automated
Microservices architectures let teams move faster, and that means there will be more to release. The catch is that you will not be able to get new changes to end users quickly if the release pipeline is jammed. Traditional releases are usually slow because the process is manual. The solution comes in two parts: standardisation and automation.
By defining the software delivery process using best-practice templates, you can provide a standard for modelling and provisioning all the infrastructure resources in a cloud environment. Templates known as 'infrastructure as code' help developers start in the right direction, because the template fully provisions the technology layer an application needs through code instead of a manual process.
With automation you can create repeatable processes that accelerate the lifecycle. These processes are called continuous integration and continuous delivery (CI/CD). Automating the release pipeline with CI/CD helps you ship high-quality code quickly and more often. In fact, Puppet's State of DevOps report finds that teams using these practices have a five times lower failure rate, a commit-to-deploy ratio 440 times faster, and 46 times more frequent releases. But the standout figure is that teams have 44% more time to create new ideas and write code instead of managing processes and tools.
Operating model: as serverless as possible
Companies prefer to adopt an operating model that makes it possible to eliminate any activity unrelated to the core competence of the business. To gain the agility that allows rapid innovation, we recommend building a microservices architecture using serverless services wherever possible.
A serverless model helps you build and run applications without provisioning and managing servers. It lets you eliminate server maintenance, scale flexibly, pay only for execution and automate high availability. The model helps us concentrate purely on the aspects of the application without having to worry about infrastructure detail.
Whether you are migrating or building new applications, going serverless will let you benefit from the greatest agility the cloud can offer.
Security: everyone's responsibility
Security has to be included at every stage of the application development lifecycle and in every component of the application. You have to make sure applications only work for their defined purpose, in order to protect the business and the end users.
In modern applications, security features are built into every component of the application and are tested and deployed automatically with every version. That means security is no longer the sole responsibility of the security team; it has to be built into every stage of development and production. Operations and the teams involved all have a part to play.
Conclusion
Modern applications create competitive differentiation by allowing rapid innovation. By changing the architectural pattern, the operating model and the software delivery process, you can shift resources from standard operations to differentiating activities. You can experiment more and turn ideas into releases faster.
You can foster an environment where developers spend more time building. Modern application development is how organisations innovate with speed and agility.
