Application Analysis and Design objectives and content for a module or course related to application design and development. Here's an overview of the topics you mentioned:
Module Objectives:
- Analyze and discuss key points in application design.
- Identify the application development checklist.
- Discuss design considerations.
- Determine application platform design.
- Create a database schema.
- Labs and Activities:
- Lab 2.1: The loaner request application
Model topics
- 2.1 Application analysis and design - Business logic and user interface
- 2.2 Build a scoped architecture data model - Database logic
User story
Analysis and design
As application developer, I need a fully understand and business process and problem, So I can design and build an app with an effective solution.
What is Application Analysis and Design?
Application analysis and design are the initial stages of the software development lifecycle. They involve gathering requirements, creating a blueprint, and defining the architecture for a software application. This process is crucial because it helps developers understand what the software should do and how it should do it. Here's a closer look at each aspect:
1. Requirements Gathering:
This phase involves engaging with stakeholders, such as clients, end-users, and subject matter experts, to understand their needs and expectations.
It's a two-way conversation where developers ask questions, gather information, and document requirements.
The goal is to create a comprehensive list of functionalities, constraints, and objectives for the software.
2. Blueprint Creation:
Once the requirements are gathered, the next step is to create a blueprint or design for the application. This includes defining the system's structure, its various components, and how they interact with each other.
It's like creating a detailed architectural plan for a building before construction begins. In software design, this often involves drawing diagrams, creating flowcharts, and outlining the user interface.
Why Application Analysis and Design are Crucial:
Clarity and Direction: The analysis and design phase provides a clear direction for the entire development team. It ensures that everyone is on the same page regarding what the software should accomplish and how it will do it.
Efficiency: By investing time upfront in analysis and design, developers can identify potential issues, bottlenecks, or gaps in the requirements. This proactive approach can save time and resources that might be wasted on correcting issues during the development or testing phases.
User-Centered: A well-designed application is user-centered. It considers the needs and preferences of the end-users, resulting in a more intuitive and user-friendly software. This, in turn, boosts user adoption and satisfaction.
Scalability and Maintainability: Proper design lays the groundwork for scalability. It ensures that the software can grow and adapt as needs change over time. Additionally, a well-designed application is easier to maintain and update, reducing long-term costs.
Risk Mitigation: Application analysis and design allow for the identification and mitigation of potential risks early in the development process. This can include security vulnerabilities, performance bottlenecks, or compliance issues.
Challenges in Application Analysis and Design:
Despite its importance, application analysis and design can be challenging. Stakeholders may not always have a clear vision of what they want, and requirements can change.
Striking the right balance between meeting current needs and preparing for future scalability can also be complex.
Application Design Process
Before embarking on the development of any application, it is crucial to establish a well-structured plan. This initial design phase lays the foundation for your project and ensures that you have a clear roadmap to follow. Your application's design should encompass three key aspects:
Business Logic:
Identify what needs to be accomplished by your application.
Define the underlying processes that the application will automate or facilitate.
Determine the primary stakeholders involved in the application's usage.
Outline the input and output data requirements.
User Interface:
Create user profiles, considering different personas that will interact with the application.
Decide on the platforms for user access, including desktop, tablet, and mobile devices.
Database Logic:
Define the database structure, specifying tables, columns, and relationships.
Consider any rules, such as 2022 terican, ne, that govern the data.
It's worth noting that your application's design might evolve during development, but starting with a well-defined plan is the most efficient approach.
Stakeholder Overview
To gain a comprehensive understanding of your application's design, it's important to consider the value it brings to various stakeholders:
Requestor:
Access from desktop, tablet, or mobile devices.
Fulfiller:
Real-time visibility to process status through reports and dashboards.
Social interaction through Live Feed.
Notifications via email.
Automation of processes.
Administrator:
Ensuring security.
Retiring legacy applications.
Designing, building, testing, and running the environment on the same platform.
Management:
Control for proactively managing requests.
Real-time visibility to process status through reports and dashboards.
Remember that this list of stakeholders is not exhaustive but serves as a starting point for your design considerations.
User Personas and Inputs/Outputs
Incorporate user personas into your design, considering various user types and their specific requirements. Additionally, define the format, frequency, and methods for data input and output.
Process Steps Definition
To develop a clear application, define the steps involved in the process. For each step, specify objectives, owners, and the detailed workflow. Consider creating flowcharts, mind maps, or swim lanes to visualize these processes, making it easier to implement workflows later on.
Designing the User Interface
Determine the platforms your application will run on, such as desktop, tablet, and smartphone. Decide the type of user experience you want to provide, considering catalog items, record producers, workspaces, portals, and mobile experiences. Ensure that you create a record producer for tables and database views within the same scope as the record producer.
Building a Data Model
The data model is crucial as it defines how your application interacts with the database. Detail the tables, columns, and relationships that your application will utilize. Create a diagram to visualize how data is stored.
Scoped Architecture and Design
Consider both client-side and server-side scripting. Keep client-side scripts minimal and maintainable. Develop a single, reusable client-side library for efficiency. Utilize Script Includes to house reusable functions. On the server-side, convert messages into appropriate logs (gs.info, gs.warn, or gs.error).
Delegated Development
Enable delegated development to expand application development to non-administrative employees while maintaining control and governance over the platform. Use scoped applications and Studio to manage development users, grant specific permissions, and specify access to resources and data.
Developer Permissions and Application-Specific Deployment
In the context of application development and deployment, it's important to understand the nuances of developer permissions and application-specific deployment settings. These aspects are crucial for effective management and governance of the ServiceNow platform.
Developer Permissions:
Developer permissions are specific to individual applications. A developer who has permissions for one application may not necessarily have permissions for another. To set developer permissions, administrators must follow these steps in ServiceNow Studio:
In Studio, navigate to "File" > "Manage Developers."
Here, administrators can set developer permissions for individual users and groups.
Administrators should have a clear understanding of the application files and the system table structure to assign developer permissions effectively. For instance, developers expected to create advanced business rules may require both "All File Types" and "Allow Scripting" developer permissions.
Application-Specific Deployment Permissions:
Application-specific deployment permissions allow administrators to designate non-administrators as developers or deployment resources for a specific application. This feature offers granular control over what actions the assigned non-administrator can perform. For instance, an administrator can allow a user to publish update sets but restrict them from publishing to the application repository or ServiceNow Store.
Instance-Specific Deployment User Roles:
In ServiceNow, administrators can also assign instance-specific deployment user roles, which empower non-admin users to install or upgrade all applications within specific instances. This is particularly useful for managing access at the instance level.
Service now recommendations
Develop private scoped applications
Give every process its own a scope
Follow delegated development practises
Track development tasks
Lab 2.1: The Loaner Request Application:
This lab provides a practical example of application development and stakeholder considerations. The goal is to build a Loaner Request application that addresses the business problem of managing loaner requests efficiently. The desired outcomes include a centralized request submission process, improved requestor satisfaction, and automation of various tasks.
Stakeholders:
The application serves various stakeholders, such as requestors, fulfillers, administrators, and management. Each group derives specific value from the application, ranging from easy access to real-time visibility, security, and process automation.
Personas:
The application caters to different user profiles or personas, each with distinct privileges and responsibilities. These personas include Employee Self-Service users, standard users, and administrators, each with varying degrees of access and control.
Inputs and Outputs:
The application interacts with various data sources, including user input forms, spreadsheets, and the Service Catalog. These sources provide the necessary data for loaner requests. The application generates outputs in various formats, including emails, notifications, and reports.
Processes:
The application defines and manages several processes to facilitate loaner requests. These processes have clear objectives, owners, and steps, ensuring efficient request management, notification, and follow-up.
Visualization:
A visual representation of the processes shows the flow and interaction between different tasks, helping users understand the loaner request workflow.
Data:
The application manages data related to loaner requests, including request details, configuration items, assignment groups, and task information. It uses various data types and references to ensure efficient data management.
By following this lab, users can gain a practical understanding of how to design, develop, and manage an application to address specific business needs and cater to the requirements of various stakeholders and user profiles. It demonstrates the power of ServiceNow in automating and streamlining complex processes.
Module Recap: Core Concepts
In this module, we have covered core concepts related to application analysis and design in the context of the ServiceNow platform. Let's recap these concepts:
Understanding the Business Problem:
Before diving into application development, it's crucial to have a clear understanding of the business problem you're aiming to solve. This forms the basis for all your subsequent design decisions.
Identifying Stakeholders:
Stakeholders are the individuals or groups who have an interest in the application and will be impacted by it. Identifying stakeholders helps in gathering requirements and ensuring the application meets their needs.
Determining Inputs and Outputs:
Inputs and outputs are essential components of any application. Identifying what data will go into the application (inputs) and what results or information it will produce (outputs) is a critical step in the design process.
Designing the Data Model:
The data model defines how data is structured and stored within the application. This includes creating tables, defining fields, and establishing relationships between data elements.
Designing the User Interface:
A well-designed user interface is crucial for providing a seamless and intuitive user experience. This step involves creating user profiles, designing UI elements, and ensuring the application aligns with user preferences.
Real-World Use Cases
Now, let's consider the real-world use cases for these capabilities:
1. Understanding the Business Problem:
Why: This capability is used to ensure that your application development efforts are focused on solving a real and pressing business problem.
When: This capability is used at the beginning of any application development project, during the initial planning phase.
How Often: This is a one-time activity for each application project, conducted at the project's outset.
2. Identifying Stakeholders:
Why: Identifying stakeholders helps gather requirements, ensuring the application caters to the needs and expectations of various user groups.
When: This capability is used at the project's beginning and continues throughout the project to involve stakeholders in the development process.
How Often: Ongoing involvement of stakeholders is necessary throughout the application's lifecycle.
3. Determining Inputs and Outputs:
Why: Inputs and outputs are the lifeblood of the application, and understanding them is essential for defining the application's functionality.
When: This capability is used at the project's beginning, during the requirements gathering phase.
How Often: This is a one-time activity for each application project.
4. Designing the Data Model:
Why: Designing the data model ensures that data is organized efficiently, and the application can perform its functions effectively.
When: This capability is used during the early design phases of the project.
How Often: This is a one-time activity for each application project, although modifications may be required over time.
5. Designing the User Interface:
Why: A well-designed user interface is essential for a positive user experience, making the application user-friendly.
When: This capability is used during the design phase of the project, focusing on how users will interact with the application.
How Often: This is typically a one-time activity for the initial application design, but periodic updates may be necessary based on user feedback and changing requirements.