Contract App Development Process: A Guide

Developing apps as a contract job is a bit special and incredibly rewarding. Technical skills are definitely important, but even more so is maintaining solid communication with clients, properly managing the scope of work, and deeply understanding the client's vision for "what kind of app they want!" and how they plan to use it in their business. In this document, we've summarized the typical flow of how our development team proceeds with contract app development and the key points to keep in mind at each stage!

1. Project Start! Let's Decide What to Build (Project Initiation and Scope Definition)

This is a super important first step where we decide the purpose of the app we're going to build, what features are needed, and how much of the work we'll be assisting with (scope). To avoid situations later like "Huh? This isn't what I expected..." or "Can you also do this?", it's key to talk thoroughly with the client and document even the smallest details!

First, let's chat! Tell us what kind of app you envision (Initial Consultation and Requirements Gathering): We'll talk with the client to understand their business, who they want the app users to be, what they want to achieve with the app, and hear their ideas like "It would be great if it had this feature." We'll ask questions to help clarify even vague points together.
"Can we technically do this?" Let's check! (Feasibility Study and Technical Assessment): We'll check if the client's requests are technically feasible. We'll investigate if there are any difficult parts, new technologies we need to challenge, or if we need to integrate with other services.
Let's clarify the extent of the work! (Scope Definition): Based on the requests, we'll clearly define the scope of work that "we will do!" and the scope that "is not included this time." We'll list what features to build, which devices the app will run on, what deliverables we'll provide, and make sure to document it properly.
How long will it take? (Estimation): Based on the defined scope, we'll estimate how much time and manpower are needed. We'll break down the work into smaller tasks and consider how long each task will take. We'll also consider if there are any difficult features, if special skills are needed, or if anything else might affect the timeline, and we'll honestly communicate the basis of our estimate.
Let's decide on the agreements! (Proposal and Contract): We'll create a proposal and contract that summarize the important agreements for proceeding with the work, such as the defined scope, estimate, timeline, payment schedule, and rights to the developed product. We'll both carefully review the contents and proceed to the next step only after agreeing, "This is OK!"
How will we communicate? (Client Communication Plan): We'll decide how and how often we'll communicate with the client. We'll also clarify the method of progress reporting (e.g., weekly meetings or reports) and who to contact.

2. Let's Think More Specifically About the App! (Planning and Design)

Once the scope is decided, the next step is to think more specifically about the app's content and appearance. This is the step where we consider technical design and user-friendly design that makes people think, "This is easy to use!"

Further details on requests! (Detailed Requirements Analysis): We'll make the initial requests even more detailed and specific. We'll firmly decide even things like what happens in what situation.
Design the app's look and feel! (UX/UI Design): We'll design the app's screen transitions, button placement, color scheme, etc. We'll create wireframes, mockups, and interactive prototypes (made with tools like Figma) to show the client, "It will look something like this!" We'll get design approval before starting development.
Design how to build the app's core! (Technical Design and Architecture): We'll technically design the app's structure, what programming languages and tools to use, how to store data, and how to integrate with other services.
Let's prepare for development! (Development Environment Setup): We'll prepare computer settings for building the app, testing environments, and places to actually publish the app. We'll also decide on code writing rules, how everyone will manage code together (using Git), and set up a system to check written code.
Automate app checks and publishing! (CI/CD Pipeline): We'll create a system to automate the flow of building, testing, and publishing the app. Doing this from the start makes things much easier later on.
Let's make a test plan! (Test Plan): We'll create a plan for various tests to ensure the app works correctly. We'll also decide on criteria for testing small parts of the program, testing how features interact with each other, and testing with the client actually using the app (UAT).

3. Time to Start Building the App! (Development)

Here, we'll actually write the app's code based on the decided design and technical specifications. In contract development, we often proceed while showing the client the progress frequently.

Build and show a little at a time! (Iterative Development): Instead of building the entire app at once, we'll divide the work into several periods (sprints) and build and show working features to the client little by little.
Meetings to show what's done (Regular Client Demos): We'll regularly show the client how the built features work. This allows us to get feedback early on, such as "Is this as you imagined?" or "I'd like this to be done this way."
Reporting "This is how things are now!" (Communication and Progress Reporting): We'll frequently report to the client on how far we've progressed, if there are any issues, and if there are any deviations from the plan.
Responding to "Actually, I want to change this" (Change Request Handling): If the client has a request like "I want to change this," we'll decide on rules for how to proceed with that. We'll inform the client how the change will affect the scope, timeline, and cost, and proceed with the work only after getting the client's OK.
Everyone checks the code! (Code Review and Quality): The team will check each other's written code to maintain high code quality, unify writing styles, and check for any issues.
We'll also test thoroughly ourselves! (Internal Testing): While building the app, we'll perform various tests ourselves, such as testing small parts of the program and where features interact.

4. Let's Check Thoroughly to See if the App Works Correctly! (Testing and Quality Assurance)

This is a very important step to ensure the app works properly and has no issues before handing it over to the client.

Testing from various angles! (Comprehensive Testing): We'll perform various tests as planned, such as checking if the app's features work correctly, if it can handle many users (performance testing), if information won't leak (security testing), and if it can be used on various smartphones and tablets (compatibility testing).
Let's fix the issues found! (Bug Fixing): We'll fix any "Hmm? Something's wrong" points (bugs) found during testing.
Let the client use it! (Client User Acceptance Testing (UAT)): We'll have the client actually use the app and check if there are any issues. We'll explain how to test and get feedback.
Listen to the client's opinions and make fixes! (Responding to UAT Feedback): We'll prioritize and address the client's opinions like "I want this fixed" and any issues found. This step is complete when the client gives their OK, saying "This is fine!"
Let's also have experts check security, etc.! (Security & Load Testing Coordination): Depending on the contract, we may ask security experts or experts who test how the app performs when many people use it. In that case, we'll properly address the issues they find.

5. Publish the App and Hand it Over to the Client! (Deployment and Handover)

After the app testing is finished and the client gives their OK, this is the step where we finally publish the app to the world or hand over everything related to the app to the client.

Let's prepare for publishing! (Deployment Plan): We'll prepare for publishing the app. We'll set up servers to run the app and create a system to monitor if the app is running correctly.
Let's put it on the app stores! (App Store Submission): If it's a smartphone app, we'll prepare to submit the app to Apple's App Store and Google Play Store. We'll summarize the app description, screenshots of the screen, what's new, etc. We'll also coordinate to get the client's account information and their OK for publishing.
Time to publish! (Deployment Execution): Once preparations are complete, we'll publish the app or submit it to the app stores.
App instruction manual! (Documentation): We'll create documentation summarizing the app's technical details, how to use it, and information needed for the client's team to manage the app.
Let's teach how to use the app! (Training): If necessary, we'll provide training to the client's team on how to use and manage the app.
"Here you go!" (Handover): We'll formally hand over the developed app's code, documentation, information needed to run the app, and anything else created during the project to the client.

6. Support Even After the App is Published! (Maintenance and Support)

Even after the app is published, there is often a period of monitoring for any issues and assisting if there are problems.

Address issues found after publishing & update! (Bug Fixing & Updates): We'll fix any issues (bugs) found after the app is published and update the app as needed.
Let's monitor if the app is running correctly! (Monitoring and Performance): We'll constantly check if the app is running smoothly and if any issues are occurring.
Promise for response speed when there's a problem (SLA Compliance): If there's an agreement (SLA) like "We'll respond within this much time" when an issue occurs, we'll adhere to it.
Let's keep in touch! (Ongoing Communication): Even after the app is published, we'll continue to talk with the client about how the app is doing, feedback from users, and how we can make it even better in the future.

7. Things to Be Especially Careful About in Contract Development

There are a few points that are especially important to keep in mind when working on a contract basis.

Contract details and billing are clear! (Clear Contract and Billing): Let's check if the contract clearly states what to build, what to do by when, and when to make payments. We'll also strictly adhere to the payment schedule.
Manage the scope of work properly! (Scope Management and Change Management): We'll be careful to prevent the scope of work initially agreed upon from gradually expanding (scope creep). If there's a request like "Actually, I want to change this!", we'll properly follow the rule of informing the client how it will affect the scope, timeline, and cost, and proceeding only after getting their OK.
Communication with the client is the most important! (Communication is Key): Promptly and openly communicating things like "This is the current situation" or "It seems there might be an issue here" to the client leads to their peace of mind and is very important for building a trusting relationship.
Whose rights are the developed products? (Intellectual Property): We'll clearly define in the contract whose property the developed app's code, design, etc., will be.
The client is a partner! (Relationship Building): Let's think of the client not just as a customer, but as a partner with whom we build the app together. Building a good relationship can also lead to future work.

This process is the basic flow for smoothly proceeding with contract app development. Of course, there are various situations depending on the project and client, so it's also important to be flexible based on this flow!

What's Contract App Development Like? Explaining the Process