Here is my plan of action

Under the Hood

For every app development whether it’s a mobile or desktop application the process or so-called plan of action remains the same.

Objective Evaluation

This is crazy shit objective must be clear and evaluated.

No objective will make things confusing and you might end up doing time-wasting things.

Now, we want to make develop an application so what are the core features, screens or pages or a few database tables that will help to evaluate the objective?

For example, the NFT selling platform needs the following

• Wallet connectivity
• Buy/Sell NFT feature
• Account balance and details page
• Products listing page And now the basic MVP objective is ready.

I always prefer to break down the goal into smaller goals.

Then treat each goal as the objective to clear out the things.

Architecture

This is my favourite part.

Objectives or goals will help to define the tech stack for any application.

Including all third-party packages and modules you need, along with database schema for the time being.

PS: All these things are temporary as the application grows more modules and packages will replace.

Now define the layout and repository structure accordingly it will become the fundamental base so choose it wisely.

My advice is to start with your cup of tea and the tools you are familiar with.

Sample Data Population

This is my new strategy nowadays.

Inject or populate the screen with sample data irrespective of the product.

There are tonnes of sample APIs available to execute that so search it online and populate sample data.

Populating sample data avoid time wasting as we don’t have to depend on backend devs or team APIs to develop pages and simple UI.

Functionality and Methods

Now we need to make things easier in future.

Add all the methods and on-click events on the entire application as the sample app.

No need to pay attention to much detail just for the time being develop it fast by adding sample methods.

For example, for the NFT marketplace, create sample NFTs data and add buy/sell functionality methods using the sample user accounts and so on.

In future, you just have to replace the logic as most of the screen work is completed.

Testing

We almost forgot this thing most of the time.

I personally prefer manual testing but this might save time.

React provides tonnes of packages to add test cases so we can use them.

Testing makes things a bit easier and clear and we can easily handle edge cases that might be missed during development and manual testing.

Testing is easy to integrate we just need to understand the logic under the hood to write decent test cases.

Ok, since this is done, we are ready with the sample application.

Injecting APIs

The last step is clear.

Inject the APIs and replace sample methods and APIs with your own APIs.

If everything went well, we are done and ready to deploy the application.

The entire process might seem familiar but we hardly do it with intention this time while developing a mobile app I am paying attention to these things.

Conclusion

The process will define the outcome.

• Clear the objective first
• Finalise the tech stack and repository architecture
• Create all pages along with sample data
• Add sample methods for the time being
• Inject final APIs along with final polishing of the methods Do give it a TRY.

Keep developing
Shrey
iHateReading