Tag Archives: Domain Model

How to Quickly Capture and Analyze Requirements for Building a Prototype or Proof of Concept?


You need to quickly capture and analyze requirements for building a prototype or proof of concept for an enterprise system.

  1. Capture any artifacts related to a business need. They may be some emails, presentation slides, a proposal document, a legacy system, some similar systems, a feature list or an initial requirement specification.
  2. Define terminologies (terms), build a background and context around the terminologies, expand the terminologies into business roles, business workflows, business components, business entities (objects), and business artifacts as much as possible.
  3. Identify the main stakeholders (roles) who will interact with the system (e.g. Guest, Admin, Developer, User, etc.) and their corresponding business problems or needs (i.e. their motivation of using the software system), and their current business workflows. Create as many scenarios (real world or domain business workflows) as possible. Create a domain model (a model of real world or domain entities, their properties and their relationships) if necessary.
  4. Identify the main components that each stakeholder will interact with (e.g. Accounts, Profiles, Reporting, APIs, Lessons, Videos, etc.) and their corresponding purposes.
  5. Identify the main tasks that each stakeholder will perform (e.g. Register an Account, Log in System, Create/Edit Profile, Create a Bucket, Generate an API Key, Create/Edit/Delete a Lesson, Create/Edit/Delete a Video, View Bandwidth, etc.).
  6. Identify the inputs and outputs and create mock-ups (sketches) or capture similar screens for each task. The quickest way to create a mock-up is to find similar existing screens in your system or external systems, and modify them. You can also search for templates of similar features in the Internet, and modify them. You can also brainstorm a  new one if you are good at creativity and imagining.
  7. Build or draw a prototype demonstrating 2 or 3 critical end-to-end workflows (An end-to-end workflow is a sequence of tasks that solves a real world problem completely). Contrast a current business workflow with a selected end-to-end workflow. The quickest way to create a prototype is to find similar existing workflow of of your system or external systems, and modify them. You can also repurpose a business workflow for a prototype. You can also brainstorm a  new one if you are good at creativity and imagining.
  8. Implement a proof of concept related to the selected end-to-end workflow.
  9. For a complicated system, you may need to implement a proof of concept, build a prototype, and create a work break down structure or product backlog in parallel to ensure that the requirements are technologically and economically feasible.


Topic 15 – Advanced Software Design

Why do I need to learn about advanced software design?

I think that I already learned about software design in the Topic 12 – Introduction to Software Design.

Now your task is not just to build a house.  Your task is to build a city. 

The situation is similar to when you create complex software. Now, you are responsible for creating a software system containing about 10,000 classes for 5,000 people to use in 15 years. The maximum system downtime must be less than 5 minutes per year.
Image that you have to create a system that serves millions of people simultaneously like Facebook or YouTube or Amazon or Office 365 or GMail. Are you able to create one?
Image that you are tasked to create a web framework for developers to extend such as ASP.NET Core or Yii or React.js. Are you confident in creating one?
If you are not sure how to fulfill these tasks then probably, you should learn how other people crafted similar systems and adapt their experiences to your case. Advanced software design knowledge will then be useful for you.

What can I do after finishing learning advanced software design?

You will know how to design a complex software system that satisfies not only functional requirements but also security, modifiability, scalability, reusability, extensibility and reliability requirements.

That sounds interesting! What should I do now?

Advanced software design requires a lot of reading. Please do review the software design knowledge introduced to you in the Topic 12 - Introduction to Software Design first.
Nowadays software can be applied to many fields. Each of them requires specific advanced software design knowledge. In this topic, we only focus on enterprise software due to its popularity.
Before you design a complicated system you must thoroughly  understand its sophisticated requirements. This is a critical step when building a large system.

Please read this David C. Hay (2002). Requirements Analysis: From Business Views to Architecture. Prentice Hall PTR book to learn how to elicit, analyze and document requirements for an enterprise system.
After that please read 
- this Deepak Alur, Dan Malks and John Crupi (2003). Core J2EE Patterns: Best Practices And Design Strategies. Prentice Hall PTR book, and
- this Martin Fowler et al. (2002). Patterns Of Enterprise Application Architecture. Addison Wesley book, and
- this Philip A. Bernstein and Eric Newcomer (2009). Principles of Transaction Processing. Second Edition. Morgan Kaufmann book.
After that please read 
- this Eric Evans (2003). Domain-Driven Design: Tackling Complexity in the Heart of Software. Addison Wesley book, and
- this Jimmy Nilsson (2006). Applying Domain-Driven Design and Patterns: With Examples in C# and .NET. Addison-Wesley Professional book, and
- this Dino Esposito and Andrea Saltarello (2014). Microsoft .NET: Architecting Applications for the Enterprise. Microsoft Press book, and
- this Vaughn Vernon (2013). Implementing Domain-Driven Design. Addison-Wesley Professional book.
After that please read 
- this Sam Newman (2021). Building Microservices: Designing Fine-Grained Systems. O'Reilly book, and
- this Sam Newman (2019). Monolith to Microservices - Evolutionary Patterns to Transform Your Monolith. O'Reilly Media book, and
- this Cloves Carneiro and Tim Schmelmer (2016). Microservices From Day One. Apress book.

After finishing the books please click Topic 16 – Calculus to continue.

Topic 9 – Software Requirements

Why do I need to learn about software requirements?

Your software can only be successful if it helps people do their work better, faster, with a lower cost. In order to achieve this objective, it must fulfill the need of various users.

To fulfill users' needs you need to be able to identify their context, problems and desires, then propose software solutions for their issues.
Your software solutions must be built based on its users' requirements. So you need to be able to collect, document, manage and validate their requirements. Software requirements engineering will provide you knowledge for completing these tasks.

Do not waste your time to create software that NO ONE will use. Your software will only become useful if its requirements are correctly engineered.

What can I do after finishing learning software requirements engineering?

You will know how to elicit, document, manage and validate software requirements so that they can be used for creating your software.

Hmm! Is it really useful?

If you have a doubt about its usefulness then you can delay learning about software requirements until you are tasked to create a software system but you do not know where to begin or what are the inputs for your coding.
Another scenarios that may suggest that you should come back to this topic is when you will have created an application but then unfortunately you find that no one wants to use it.

Alright! What should I do now?

Please read 
- this Suzanne Robertson and James Robertson (2012). Mastering the Requirements Process. Addison Wesley Professional book, and
- this Karl Wiegers and Joy Beatty (2013). Software Requirements. Microsoft Press book.

After that please read this Joy Beatty and Anthony Chen (2012). Visual Models for Software Requirements. Microsoft Press book.

After that, please read this Alistair Cockburn (2001). Writing Effective Use Cases. Addison-Wesley book.

Then please review this ISO/IEC/IEEE 29148:2011(E) standard so that you could create a quality software requirements specification for projects require high formal specification.
After that please read this Mike Cohn (2004). User Stories Applied: For Agile Software Development. Addison-Wesley Professional book.

After that please read this Jeff Patton and Peter Economy (2014). User Story Mapping. O'Reilly Media book.

After that please read this Dean Leffingwell (2011). Agile Software Requirements. Lean Requirements Practices for Teams, Programs, and the Enterprise. Addison-Wesley Professional book
After that please read this Project Management Institute (2015). Business Analysis for Practitioners - A Practice Guide. Project Management Institute book.
After finishing the books please click Topic 10 - Software Construction to continue.