Tips For Building Production Ready Applications
Tags: productivity, javascript, node, tutorial
Published: 2021-01-11 17:51:21

Good day people of Earth ^_^^_^

Have you ever been stuck building a product that you wish to put into the market but you don't know if you are doing the right way ?

I guess we all are. Here's an extensive list I compiled to provide you tips on how to build your application the right way.

1. Do a lot of research before choosing a language to use and tools you wish to use :
Researching on the tools you want to make use of is very essential because it will save you a lot of time at the long run.
There's this saying that goes like this : "Hit the nail with a hammer". In order words, use the right tools for a project else you will face troubles in the future.

2. Learn to make use of architectures that makes your codebase look clean and not that complex :
There are different architectures when it comes to building applications. They vary with different architectural designs and patterns. Choosing the best architecture makes your codebase look more cleaner and even save you the stress of debugging it.

3. Use a week to carry out some research before starting the project : 
It's usually advisable to use about a week to carry out research because you get a long time to decide on what tools to use and plan the project carefully.

4. Learn to write tests:
Who doesn't write tests in the 21st century ?
From the onset, writing tests are a useful way of saving you the stress of testing your application manually. 
One of the best part about writing tests is that you can test multiple components and features in one go . 

5. Don't follow trends:
Following trends is one of the things that allows developer change the tool they are good at to something else due to trends.
 No one is saying trends are not good but you have to set your mind and goal on a particular tool and use it throughout your project.

6. Avoid over complexity:
If your codebase is private, don't make it too complex afterall no one is reading your codes. Also if it's open source, do the same and make it easy to read and navigate.

7. Avoid logging server errors into the console :
Sometimes the users don't need to know the type of error that happened to your application because if they find such information, they can use it to do malicious things to your application. 
A simple response or status code can be used too.

8. Add rate limiting packages: 
Rate limiting is a technique used by developers to limit the amount of requests that are sent to a server.
A website that lacks rate limiting tools is likely prone to DDOS attacks and brute force attacks since they can keep making countless request to your server till it crashes.

9. If there are a lot of data that needs to be processed, use a multi-threaded or asynchronous tools :
Multi-threaded tools provide a much better way to handle operations and tasks with ease. Also asynchronous tools can be helpful in processing data with non-blocking I/O. Like I said in number 1, using the right tool matters . 

10. Test your application for bugs and flaws :
Sometimes if writing tests doesn't work out or you want to go further then you should consider using some tools to test your application.
Tools like OWASP can be used to test your application for loopholes and security issues.

11. Urge users to try out your app before launching:
Users are the people who use your product and without them, your product is as good as dead.
Urging users to try out your application before launching makes you get necessary feedback on it and what to change or fix.

12. If your app requires authentication, make use of stateless sessions :
Stateless sessions are sessions that don't really require sessions. They are stateless which means hey are persistent.
JWT is a typical example of stateless sessions which allows you to authenticate users without using sessions that can be easily hijacked.

13. Learn how to modularize your codes:
Modularization is the process of separating codes into modules that could be easily accessed within the project.
Modularizing codes makes
it easier to test your components or features independently and provide a clean code base.

14. Version your API or product:
When you version your product, you're giving your users the option to choose between the old or new version of your product.
Part of the reason why versioning your product is effective is because some of the new features you added might not work for some computer or phones which means users can't use your product.

15. Always run tests on your NPM package: 
NPM has a lot of weak and vulnerable packages which might not be safe to work with or they exposed your data.
Running tests and fixing them is very effective in the long run because you will have that assurance that your data is safe. You can use Synk, a NPM package for running tests on your codebase or you could run ``` npm audit fix ``` to fix all the vulnerable packages.

16. Use cron jobs:
Cron jobs are basically tasks or operations meant to be carried out at a particular period of time. Using cron jobs helps you to perform specific tasks automatically. E.g deactivate unverified users account after 3 weeks of registration. This method allows you to be flexible and do a lot of neat work without doing it manually.

17. Use git to track and maintain your codebase:
Git is a source control system while GitHub is a site that uses Git.
With Git, you have the ability to track changes made to your code base and maintain them when needed.
Think of Git as a cloud for your codebase where you can review what your changes.

18. Separate your production branch from your development branch:
A lot of people most especially people who are just starting to use GitHub make the mistake of pushing and deploying their codes on a single branch usually the ``` master ``` branch.
This is not advisable because you might end up committing a bug in your codes which is later deployed to your server and can cause a lot of serious damage to the users and application.
Creating different branches to aid development and also production helps a lot .

19. Never ignore errors:
Errors are every developer nightmare. They are capable of completely shutting down your application which is bad for your users.
Take errors seriously and try to fix them no matter the circumstance.

20. Spend most of your time building a good UI and UX:
A good UI and UX are what attract users to your application which means spending your time building it makes your product worth using. A bad UI and UX displeases your users and makes you lose some potential users in future.

21. Process requests properly:
Sometimes most requests that are sent to your server can contain malicious data that is capable of breaking down the system or exposing the data of the user. 
Checking these requests for flaws or abnormal behavior and processing them properly is a good way of checkmating such malicious acts.

22. Always sanitize and validate users input before storing them:
Validating users input before storing them is very crucial because they might be some irregularities that hackers could take advantage of. 
When you sanitize and validate users input, you are making sure that the data that are collected from them are safe and wouldn't cause harm to the system in future.

23. Always hash or encrypt your users password before saving them :
Encrypting users password before storing them helps to keep them safe and very hard to hack into.
Using this process, if a hacker gets hold of your information, he/she can't be able to access your account due to the encrypted password.

24. Never display error messages from your product API:
Error message coming from the server end are meant to be hidden away from the users. 
A simple response can prove useful and safe.

25. Performance and speed is numero uno of all good applications :
The key to a production ready application is performance and speed. They are what make users
to use your product. Good performance and speed will urge users to continue to make use of your product.

25. Provide useful and insightful documentation about your project:
No product is ever complete without a documentation. Documentations are guidelines for the users on how to get started with your product and what it entails. Proper documentation allows the user to understand your product properly.

26. Don't be greedy when paying for services that could help secure your application:
Some people have the habit of using free services that are not usually safe or provide better security for your application.
Paying for the right services to secure your application might be worth a shot and can even give you guarantee that you wouldn't be facing issues with it.

27. Learn to use sockets efficiently:
Sockets are very useful if you know how to make use of them effectively and dangerous if you don't know what you are doing.
Sockets are ways of passing data from one service to another in real time and is very cool to use in enterprise application or applications that require real time data.

28.  Build what both you and the users love:
Before building a product, ask yourself one question which is : ``` Will the users like my application and idea ```.
Sometimes they don't but you just have to make it work. When your passion to build something fails, then the purpose of it should drive you.

29. The users are the main people who keep your application intact:
Value your users and customers because they are the ones using your application .

30. Upgrade your product when due:
Some people have to habit of not updating the service they use and their product when outdated. 
Upgrading your product when it's outdated will allow the users to be sure that the upgrade is for their own interest.

31. Separate your business logic from your application logic:
Your business logic should be separated from your application logic especially when working with the Clean Architecture. 
This method is very effective because it doesn't allow some vital information to be exposed to the users and also it is easy to regulate and maintain.
Basically, your application logic is the logic that your application needs to do to keep it running e.g connect to the database, run cron jobs etc... while your business logic is the logic that your application is built on e.g create a wallet on user registration.

32. Use env variables for storing keys/configs:
Storing keys or special configuration is something that should be handled properly. Such keys are meant to be stored in a safe place from preying eyes.
The new method of storing such keys is using a .env file which can be hidden from usrs.

33. Don't be afraid to take critiques or feedback from users:
Like I said earlier on, taking feedbacks from users doesn't make you the lesser person. They are just ways to improve your application and prevent your from occuring a loss in the future.

34. Use HTTPS:
The most secured and standard protocol is HTTPS. This protocol allows you to be assured that your product is running on a secured platform.

35. Be careful when integrating third party APIs to your application:
Third party APIs are one the ways users information can be easily breached. Integrating such APIs are risky and are meant to be reviewed with care.
Check reviews from other people who have tried it out before trying it out .

36. Use languages like Ruby, Golang, C# or Java for enterprise application:
Use the right tools to complete the job with no stress. 
Multi-threaded tools like those languages help you to carry out process and tasks simultaneously with ease which is the basis of every enterprise application.

37. Spend as much time in ensuring your application is ready :
Don't rush in pushing your application to the market, run some checks on them to make sure that it is fit to be in the market and can be used by people.

38. Use state management:
State management is a method that allows you to manage the state of your application at a given period of time.
Sometimes , users perform a lot of operations which alter the current state of the application and emit a lot of events. If such events are not managed properly, your application will be messy.
Using state management tools or packages help you to handle states effectively.

39. Avoid hosting your product on free domain or unsecured sites with HTTP:
Hosting a marketable product on a free domain or on unsecured sites discourages users from using your application because they feel like their data is not safe or secured.
Privacy and security is one of the reasons why users use the platform they use.

40. Use caching when necessary:
Caching is a technique used to store data in a computer memory which can be retrieved later but in a faster way. Caching is very useful but sometimes not using it well makes your application weak or not functional since it's not getting updated data .
This technique is very effective when used properly.

Thanks for taking your time reading this article and I really appreciate.
You can follow me here and on Twitter using my handle : https://twitter.com/geekayahmed