কোর্স · বহুভাষিকমধ্যমBackend Engineering-এর ধাপ 2

Backend Engineering with Java & Spring Boot

Build Production-Ready Backend Systems with Java, Spring Boot, PostgreSQL, and Modern Engineering Practices

প্রদানকারীTarkev
  • 14টি মডিউল
  • 159টি পাঠ
  • 16 সপ্তাহ
  • বহুভাষিক
  • প্রতিটি পাঠে Fumuযেকোনো পাঠের ভেতরে Fumu-কে জিজ্ঞেস করুন। আপনি যে পাঠে আছেন, তার ভিত্তিতেই সে বিষয়টি বুঝিয়ে দেয়।
  • আপনার প্রোফাইলে একটি যাচাইকৃত সার্টিফিকেটশীঘ্রইকোর্স শেষ করার দিনই আপনার পাবলিক প্রোফাইলে যোগ হবে, আপনার যাচাইকৃত পরিচয়ের সাথে যুক্ত থাকবে।
কোর্সের সারসংক্ষেপ

এই কোর্স সম্পর্কে

It’s time to move from the foundations of Java and Object-Oriented Programming into real-world backend development.

In this course, you won’t just learn Spring Boot features or annotations. You will build a production-style backend application from the ground up, step by step, and learn professional backend development through the process.

The course follows the workflow of a real engineering team—from understanding requirements and creating technical designs, RFCs, and engineering tickets to implementation, testing, code review, deployment, and investigating production issues.

Throughout the course, the same application will continue to evolve. Instead of learning each new concept through isolated examples, you will see where it fits in a real system, why it is needed, and how it is applied in practice.

The goal of this course is not simply to complete a backend project.

The goal is to build the foundation you need as a backend engineer to think about, design, build, and maintain production-quality software.

পাঠ্যক্রম

14টি মডিউল · 159টি পাঠ · 31টি বিনামূল্যে প্রিভিউ
1Joining the Backend Team10টি পাঠ3টি প্রিভিউBefore any code exists, this module does the work a new backend engineer does in the first weeks on a team. You read the Product Manager's brief for the Order Management Backend and separate what it says from what you are tempted to assume, sort its requirements into functional behaviour and non-functional qualities, and turn the capabilities into User Stories with testable Acceptance Criteria. Then you learn the engineering context the system must fit, agree a Definition of Done, and break the work into the `BACKEND-101` to `BACKEND-128` backlog that the rest of the course implements, ordered by dependency, value and risk. The exercises produce the team's real working documents in your own `docs/` folder: a requirement review, Stories, a context document, a DoD review and a backlog plan.
  1. 1.1 Welcome to the Engineering Teamভিডিও ও পড়া · 21 মিনিটপ্রিভিউ
  2. 1.2 Understanding the Product Requirementভিডিও ও পড়া · 25 মিনিটপ্রিভিউ
  3. 1.3 Functional vs Non-Functional Requirementsভিডিও ও পড়া · 24 মিনিটপ্রিভিউ
  4. 1.4 User Stories and Acceptance Criteriaপড়া
  5. 1.5 Understanding the Existing Engineering Contextপড়া
  6. 1.6 Definition of Doneপড়া
  7. 1.7 Creating Our Initial Engineering Backlogপড়া
  8. 1.8 Prioritizing and Refining the Backlogপড়া
  9. এই মডিউলে আরও 2টি পাঠ
2Designing the System8টি পাঠ2টি প্রিভিউBefore the first line of code, the team turns the agreed requirements into a design it can review. This module finds the domain concepts and decides which have identity: Product, a separate Inventory, Order with its OrderItems and purchase-time prices, and a `CustomerId` from the identity capability instead of a local Customer. It assigns each responsibility to handlers, use cases, domain objects, repositories or the `PaymentService` boundary, and shapes them into a modular monolith with one package per capability. The design is then written down as RFC-001, its durable decisions are recorded as ADR-001 to ADR-005, and a review sharpens vague requirements, rejects speculative infrastructure and decides what is ready to build. Every exercise produces a design document that you keep in your project's `docs/` folder.
  1. 2.1 From Requirements to Technical Designপড়া · 17 মিনিটপ্রিভিউ
  2. 2.2 Identifying Domain Entitiesপড়া · 19 মিনিটপ্রিভিউ
  3. 2.3 Defining System Responsibilitiesপড়া
  4. 2.4 Designing the Initial Architectureপড়া
  5. 2.5 Writing Our First RFCভিডিও ও পড়া · 11 মিনিট
  6. 2.6 Architecture Decision Recordsপড়া
  7. 2.7 Reviewing and Revising a Technical Designপড়া
  8. 2.8 Module 2 Practice Solutions: Lessons 2.01–2.07পড়া
3Building the Spring Boot Application10টি পাঠ3টি প্রিভিউThe design is approved; this module starts the code. You create the `order-management` repository with Spring Initializr and complete the first ticket, `BACKEND-101`: a Gradle build that works from a clean checkout, a Spring Boot entry point and a context test. Then the module explains what the framework does with it: how project structure decides what Spring finds, how Dependency Injection and the Application Context build the object graph, and why startup fails when a Bean is missing, ambiguous or part of a cycle. It sets the rules for configuration, profiles and secrets, the package convention every later ticket follows, and the local workflow with PostgreSQL in Docker Compose. At the end, the project builds, its test passes without a database, and it starts with the `local` profile.
  1. 3.1 Creating a Spring Boot Applicationপড়া · 16 মিনিটপ্রিভিউ
  2. 3.2 Understanding Spring Boot Project Structureপড়া · 12 মিনিটপ্রিভিউ
  3. 3.3 Dependency Injectionপড়া · 14 মিনিটপ্রিভিউ
  4. 3.4 Beans and the Application Contextপড়া
  5. 3.5 Configuration and Application Propertiesপড়া
  6. 3.6 Environment-Specific Configurationপড়া
  7. 3.7 Structuring a Backend Codebaseপড়া
  8. 3.8 Running the Application Locallyপড়া
  9. এই মডিউলে আরও 2টি পাঠ
4Domain Modeling10টি পাঠ2টি প্রিভিউThe application starts, but it holds no business code yet; this module writes its core. Product, Inventory, Order, OrderItem and the typed IDs become plain Java classes that protect their own rules: a price is never negative, stock never drops below zero, an Order has at least one line, keeps its purchase-time prices, derives its total with exact arithmetic and moves only from `UNPAID` to `PAID` or `CANCELLED`. Along the way the module separates entities, value objects and DTOs, keeps HTTP, security and persistence out of the domain, decides what Customer means when another system owns identity, and finds the line between a passive data holder and an object that does too much. Every rule is tested with plain JUnit, without Spring or a database.
  1. 4.1 Turning Business Concepts into Domain Modelsপড়া · 13 মিনিটপ্রিভিউ
  2. 4.2 Entities, Value Objects, and DTOsপড়া · 18 মিনিটপ্রিভিউ
  3. 4.3 Separating Domain Logic from Transport Logicপড়া
  4. 4.4 Modeling Productপড়া
  5. 4.5 Modeling Customerপড়া
  6. 4.6 Modeling Orders and Order Itemsপড়া
  7. 4.7 Modeling Order Stateপড়া
  8. 4.8 Avoiding Anemic Domain Modelsপড়া
  9. এই মডিউলে আরও 2টি পাঠ
আরও 10টি মডিউল · 121টি পাঠ
এই কোর্সের পরে

Backend Engineering রোডম্যাপের শেষ কোর্স

এই কোর্সটি 2টির মধ্যে 2 নম্বর ধাপে: Build APIs।

পুরো রোডম্যাপ দেখুন