In this article, we would like to share the process we apply to our software and mobile app development project. We believe a good process is critical to the successful launch of a product.
When we talk with customers, first thing we look at is user requirements. Sometimes customers have an idea of what they want to do, however they haven’t documented it down clearly. Here comes our role. We seek the answers to the following:
- A 2-3 sentence paragraph to summarize the product, as if it were being communicated to an end-user/buyer.
- Who are the users? They can be separated into groups such as Learners, Instructors, Institution Representatives. And for each group, how do they interact with the product? You can use a simple list to note down. It can even be repetitive. The whole point is to get out as many details as possible. Later on you can always piece it together.
- Now look into what you gather above, see if you can identify any features that require input from more than 1 group of users. Also, see if there’s a workflow involved. For example, when applying for a leave request (employee leave request), the process requires at least an employee to submit the request and another employee (superior) to approve or reject it. With the information gathered, you can draw up a business process chart like this:
Graphical User Interface (GUI) Design
What you see is what you get. The GUI is usually an easiest way to confirm if we have understood customer requirements. However, we don’t have to draw up everything.
Here is where we apply the Parento principle: identify the core essentials, the MVP (minimum viable product), the 20% that users will spend 80% of their use time. For example, most Facebook users will spend 80% of their time with the News Feed. Thus News Feed is the core essentials, everything else can have less priority (even less friendly and more buggy!). Simply because with your MVP, product can launch and revenue can start streaming in for further development.
There 2 components that we work on:
- UI flow: the basic screen flow structure to help us visualize how users move from one click to another (one screen to the next).
- Detailed design of each individual screen.
Here’s an example of a final design:
Test Spec Design
Once we have got a clear idea of what to develop, our testers start to create test cases and test data. We don’t have to wait until the coding starts in order to do this. In fact, this step may reveal some loop hole in our requirements, design and process.
Depending on each project, there may be 2 types of work involved:
- We design our test cases and scenario data into an Excel sheet table and run through each case as we test.
- We run Unit Testing on our key code. This can be automated and it can also handle large amount of test data.
UML & Database Design (Technical Design)
This is where the software engineers get busy, they will look at the requirements and GUI provided and translate that into technical design that software programmers (oftentimes the same bunch of guys) can depend on to write code. Technical design is a critical step in producing quality code. It’s the blueprint.
We use tools like GitLab and Jira to manage our coding workflow, collaboration and source code revisions. We also utilize continuous integration and deployment provided by these tools to deploy our code to respective servers (such as test server, user acceptance server, etc.).
We also use tool like Swagger to document Web Service API.
Test Execution & Production Release
With each completed features (or set of features), our testers perform quality test according to the design test spec. If test passes internal review, it’ll move on to be presented to users for user testing. Once all is good, we’ll deploy the code and any other changes to the production/live server.
Even when we user Continuous Deployment provided by GitLab and the like, we still produces an implementation notice document to help both software developers and project managers keep quality. This is a good practice.
In summary, a clear process is key to a successful project. What we’ve shared here are key steps we take. Depending on each project, we may deploy additional process as we see fit and as customer requires.
It’s useful to note we can break down development of software/app features into smaller chunks (sprints) and apply above process to each of them. At times, we also execute them concurrently, e.g. while UI designer does UI work and tester prepares test spec, engineering team can go ahead with technical design.
Equally important is the fact that our project manager keeps a close watch on on-going documentations of requirements and design changes. You may also read more about how we overcome language barrier and cross-cultural communications in this article.
As a final word, our team is committed to work together to make sure you succeed.