VOOZH about

URL: https://www.coursera.org/learn/packt-software-architecture-foundations-and-intro-to-microservices-l0tqw

⇱ Foundations of Software Architecture and Monolithic Systems | Coursera

Foundations of Software Architecture and Monolithic Systems

Keep adding new skills with 10,000+ programs for $239 (usually $399). Save now.

Foundations of Software Architecture and Monolithic Systems

2,149 already enrolled

Included with

Ask Coursera

Gain insight into a topic and learn the fundamentals.
4.2

10 reviews

Intermediate level

Recommended experience

8 hours to complete
Flexible schedule
Learn at your own pace
Gain insight into a topic and learn the fundamentals.
4.2

10 reviews

Intermediate level

Recommended experience

8 hours to complete
Flexible schedule
Learn at your own pace

What you'll learn

  • Master monolithic architecture and design scalable applications with key principles like KISS, YAGNI, and DRY.

  • Learn how to decompose monolithic systems into microservices for enhanced flexibility and scalability.

  • Understand the concepts of vertical and horizontal scaling and apply them to optimize application performance.

  • Gain hands-on experience with building, coding, and scaling real-world systems like e-commerce applications.

Details to know

Shareable certificate

Add to your LinkedIn profile

Assessments

7 assignments

Taught in English

Build your subject-matter expertise

This course is part of the Microservices Architecture: Design Patterns & Principles Specialization
When you enroll in this course, you'll also be enrolled in this Specialization.
  • Learn new concepts from industry experts
  • Gain a foundational understanding of a subject or tool
  • Develop job-relevant skills with hands-on projects
  • Earn a shareable career certificate

There are 6 modules in this course

This course features Coursera Coach!

A smarter way to learn with interactive, real-time conversations that help you test your knowledge, challenge assumptions, and deepen your understanding as you progress through the course. This course will immerse you in the core concepts of software architecture with a focus on monolithic systems. You will learn about the evolution of architecture, from traditional designs to modern microservices systems, and explore the design principles that influence these systems. Through real-world examples and problem-solving scenarios, you will design, code, and evaluate software systems to develop a solid understanding of architecture patterns. Starting with the foundations of monolithic architecture, you will be introduced to key design principles such as KISS, YAGNI, and DRY. These will be applied in building real-world applications, including an e-commerce platform. You’ll also dive into scalable systems, learning vertical and horizontal scaling techniques and their applications. The course is intended for software developers and engineers who want to deepen their understanding of monolithic and microservices architectures. A basic knowledge of programming is required, making this course ideal for those looking to expand their architectural skills and work on scalable systems. By the end of the course, you will be able to design, code, and scale monolithic systems, implement modular monoliths, and apply microservices architecture. You will also be able to optimize system performance using scalability strategies and improve system flexibility.

In this module, we will introduce the course, its key objectives, and what you will learn. You’ll also gain insights into the course structure, which follows a problem-solving approach to help you apply concepts practically.

What's included

5 videos2 readings

5 videos•Total 28 minutes
  • Introduction to the Specialization•8 minutes
  • Architecture Design Journey - Evolution of Architectures•7 minutes
  • Way of Learning - The Course Flow: Problem -> Learn -> Design -> Code -> Eva•7 minutes
  • Prerequisites, Source Code and Course Slides•4 minutes
  • First Problem: Sell Products Online: Understand E-Commerce Domain•3 minutes
2 readings•Total 20 minutes
  • Introduction to the course 'Foundations of Software Architecture and Monolithic Systems'•10 minutes
  • Full Specialization Resources•10 minutes

In this module, we will introduce the course, its key objectives, and what you will learn. You’ll also gain insights into the course structure, which follows a problem-solving approach to help you apply concepts practically.

What's included

13 videos1 assignment

13 videos•Total 74 minutes
  • Monolithic Architecture: When to Use, Benefits and Challenges•7 minutes
  • Foundational Design Principles: KISS, YAGNI, DRY•4 minutes
  • Design: EShop Monolithic App w/ KISS & YAGNI•6 minutes
  • Code: EShop Monolithic App w/ KISS & YAGNI•9 minutes
  • Problem: Customer Basket Items Disappeared When App Restarts•5 minutes
  • Design: E-Shop Monolithic App with a Persistent Database•3 minutes
  • Code: E-Shop Monolithic App with PostgreSQL Database•9 minutes
  • Problem: Tightly Coupled UI Limits Flexibility and User Experience•3 minutes
  • Learn: 3-Tier Architecture – Separating Presentation, Application, and Data•6 minutes
  • Design: E-Shop Monolithic App with 3-Tier Architecture•3 minutes
  • Code: E-Shop with 3-Tier Architecture (SPA, Backend API & Database)•12 minutes
  • Big Ball of Mud•1 minute
  • Problem: Growing Pains-Our Monolith is Becoming Hard to Manage and Evolve•4 minutes
1 assignment•Total 15 minutes
  • Monolithic Architecture - Assessment•15 minutes

In this module, we will dive into modular monoliths, learning how to break applications into modules for greater maintainability. You will design and implement an e-commerce application using this architecture while addressing performance optimization and vertical scaling concerns.

What's included

10 videos1 assignment

10 videos•Total 62 minutes
  • Modular Monoliths Architecture: When to Use, Benefits and Challenges•8 minutes
  • Design: E-Shop Modular Monoliths Architecture•5 minutes
  • Best Practice: DB Schema Separation of Modules in Modular Monoliths Apps•3 minutes
  • Code: E-Shop Modular Monoliths Architecture•12 minutes
  • Monoliths Vertical Considerations (Communication, Transactions, Deployments)•6 minutes
  • Problem: Product Page Slowness - Failures During Peak Traffic•4 minutes
  • Learn: Output Caching – Speeding Up Repetitive Requests•6 minutes
  • Design: E-Shop Modular Monoliths with Redis Output Caching•5 minutes
  • Code: E-Shop Modular Monoliths with Redis Output Caching•10 minutes
  • Problem: Increased Traffic, Can't Handle More Request w/ Single App Instance•3 minutes
1 assignment•Total 15 minutes
  • Modular Monolithic Architecture - Assessment•15 minutes

In this module, we will explore scalability concepts and discuss how to efficiently scale applications. You’ll learn about vertical and horizontal scaling and implement a load-balanced e-commerce system capable of handling increased traffic.

What's included

6 videos1 assignment

6 videos•Total 36 minutes
  • Learn: Scalability - Why Need to Scale?•2 minutes
  • Vertical and Horizontal Scaling•6 minutes
  • What is Load Balancer? Use Load Balancer Splitting the Load•6 minutes
  • Design: E-Shop Monolithic App with Horizontal Scaling and Load Balancer•7 minutes
  • Code: E-Shop Monolithic App with Horizontal Scaling•9 minutes
  • Problem: Ship New Features Faster to Compete in the Market•5 minutes
1 assignment•Total 15 minutes
  • Scalability - Vertical and Horizontal Scaling - Assessment•15 minutes

In this module, we will introduce microservices and discuss their architecture. You will gain the skills to decompose applications into smaller, independent services and apply microservices principles to design and code an e-commerce system.

What's included

6 videos1 assignment

6 videos•Total 47 minutes
  • What Are Microservices and Microservices Architecture?•8 minutes
  • When to Use / When NOT to Use Microservices Architecture•8 minutes
  • The Database-per-Service Pattern - Polyglot Persistence•5 minutes
  • Design: E-Shop Microservices Architecture•7 minutes
  • Code: E-Shop Microservices Architecture•16 minutes
  • Problem: Validating Our Service Boundaries - How to Decompose Microservices•3 minutes
1 assignment•Total 15 minutes
  • Microservices Architecture - Assessment•15 minutes

In this module, we will focus on strategies for decomposing a monolithic application into microservices. You’ll learn about key decomposition patterns and practical approaches like the Strangler Fig Pattern to ensure a smooth transition from monolithic to microservices.

What's included

5 videos1 reading3 assignments

5 videos•Total 26 minutes
  • Decomposition of Microservices Architectures•4 minutes
  • Microservice Decomposition Patterns: Decompose by Business Capability, SubDomain•6 minutes
  • Identifying and Decomposing Microservices for E-Shop Domain•7 minutes
  • Strangler Fig Pattern for Refactoring Monoliths into Microservices•6 minutes
  • Problem: How Microservices Communicate with Each Other•2 minutes
1 reading•Total 10 minutes
  • Conclusion to the Course 'Foundations of Software Architecture and Monolithic Systems'•10 minutes
3 assignments•Total 90 minutes
  • Microservices Decomposition Strategies - Assessment•15 minutes
  • Full Course Assessment•60 minutes
  • Full Course Practice Assessment•15 minutes

Earn a career certificate

Add this credential to your LinkedIn profile, resume, or CV. Share it on social media and in your performance review.

Instructor

Offered by

Explore more from Cloud Computing

Why people choose Coursera for their career

👁 Image

Felipe M.

Learner since 2018
"To be able to take courses at my own pace and rhythm has been an amazing experience. I can learn whenever it fits my schedule and mood."
👁 Image

Jennifer J.

Learner since 2020
"I directly applied the concepts and skills I learned from my courses to an exciting new project at work."
👁 Image

Larry W.

Learner since 2021
"When I need courses on topics that my university doesn't offer, Coursera is one of the best places to go."
👁 Image

Chaitanya A.

"Learning isn't just about being better at your job: it's so much more than that. Coursera allows me to learn without limits."

Frequently asked questions

Software architecture refers to the high-level structure of a software system, encompassing its components, their interactions, and how they align with business goals. It's a crucial element because it determines the scalability, performance, and maintainability of software systems. Understanding architectural principles is essential for building robust systems that can evolve over time while meeting user and business needs.

This course covers foundational software architecture principles, focusing on monolithic systems. It explores the evolution of architectures from traditional monolithic designs to more modern approaches, such as microservices. The course provides practical experience in designing and coding applications using monolithic architectures, applying design principles like KISS, YAGNI, and DRY, and addressing real-world issues like performance and scalability.

Upon completing this course, you'll be able to design and develop monolithic applications with a focus on simplicity, modularity, and scalability. You'll also understand how to solve common issues in monolithic systems, such as performance bottlenecks and data persistence challenges. Additionally, you'll gain the skills necessary to decide when to use monolithic designs and how to evolve them as systems grow.

This course assumes a basic understanding of programming and software development principles. Familiarity with web development, databases, and fundamental coding practices will help, but no prior knowledge of specific architecture patterns is required. The course will guide you through the concepts and practical applications step by step.

This course is designed for software developers, engineers, and architects who are looking to understand and apply monolithic architecture principles. It's also suitable for those who are working on large-scale applications and want to learn about architectural patterns that can be used to build robust and maintainable software systems.

The course contains 4 hours of video content, but the time to complete the course may vary depending on how much time you dedicate to the exercises, coding challenges, and reviewing the materials. On average, you can expect to complete the course in a few days if you pace yourself.

Yes, you can preview the first video and view the syllabus before you enroll. You must purchase the course to access content not included in the preview.

If you decide to enroll in the course before the session start date, you will have access to all of the lecture videos and readings for the course. You’ll be able to submit assignments once the session starts.

Once you enroll and your session begins, you will have access to all videos and other resources, including reading items and the course discussion forum. You’ll be able to view and submit practice assessments, and complete required graded assignments to earn a grade and a Course Certificate.

If you complete the course successfully, your electronic Course Certificate will be added to your Accomplishments page - from there, you can print your Course Certificate or add it to your LinkedIn profile.

This course is currently available only to learners who have paid or received financial aid, when available.

Yes. In select learning programs, you can apply for financial aid or a scholarship if you can’t afford the enrollment fee. If fin aid or scholarship is available for your learning program selection, you’ll find a link to apply on the description page.

Financial aid available,