Optimizing and Deploying Your React DApp on Celo: Best Practices for Production-Ready Decentralized Applications


Ahoy, fellow knowledge-seekers!:blush: Prepare to embark on the final leg of our thrilling NFT Marketplace journey, where we shall delve into the mystical arts of optimizing and deploying your very own dApp. Brace yourselves for an exhilarating tutorial, brimming with technical prowess and creative finesse, as we set sail toward the culmination of our NFT series. Welcome, one and all!

Why Optimize and Deploy Your Dapp

Why Optimize and Deploy Your NFT Marketplace?

Optimizing and deploying your NFT Marketplace is a critical step in bringing your vision to life and ensuring a seamless user experience. This section explores the key reasons why optimization and deployment are vital for the success of your NFT Marketplace.

  1. Enhanced Performance: Optimization plays a crucial role in improving the overall performance of your NFT Marketplace. By fine-tuning various aspects such as code efficiency, database queries, and caching mechanisms, you can achieve faster loading times, smoother interactions, and reduced latency. These improvements contribute to a delightful user experience, increasing user engagement and satisfaction.

  2. Scalability and Handling Traffic: As your NFT Marketplace gains popularity, it’s essential to be prepared for increasing traffic and user demand. Optimizing your platform enables it to handle higher volumes of users and transactions without sacrificing performance. Implementing efficient resource management techniques, such as load balancing and horizontal scaling, ensures that your NFT Marketplace remains robust, responsive, and capable of accommodating a growing user base.

  3. Security and Stability: Deploying your NFT Marketplace involves setting up secure hosting environments and following best practices to protect user data, digital assets, and transactions. By adopting security measures like encryption, secure authentication protocols, and vulnerability scanning, you can safeguard your platform from potential cyber threats and maintain trust among your users. Regular updates and maintenance also contribute to the stability and reliability of your marketplace.

  4. Availability and Accessibility: Deploying your NFT Marketplace ensures that it is accessible to users around the clock. By leveraging cloud-based hosting services or dedicated servers, you can achieve high availability, minimizing downtime and maximizing user access to your platform. This accessibility factor is crucial for attracting a global user base and facilitating continuous trading and interaction within your NFT ecosystem.

  5. Monetization Opportunities: Optimization and deployment pave the way for various monetization strategies within your NFT Marketplace. Once your platform is efficiently optimized, you can explore revenue streams such as transaction fees, listing fees, featured listings, premium memberships, or even collaborating with artists and creators for exclusive releases. These monetization avenues allow you to generate income and sustain the growth and evolution of your NFT Marketplace.


  • Prior knowledge of javascript
  • Familiarity with the command line
  • Basic understanding of blockchain concepts
  • Have some knowledge of solidity and its concepts


  • NodeJS from V12.or higher
  • A code editor or text editor. VSCode is recommended
  • A terminal. Git Bash is recommended
  • An Internet Browser and a good internet connection
  • An account on netlify


To provide context to the contract code being referenced throughout the tutorial, here is the code:


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

contract MyNFT is ERC721, Ownable, ERC721Enumerable, ERC721URIStorage {
    using Counters for Counters.Counter;

    Counters.Counter private _tokenIdCounter;
    address contractAddress;

    constructor(address marketplace) ERC721("Dripto Ponks", "DPT") {
        contractAddress = marketplace;

    uint256 _tokenId = 0;

    function mint(string memory uri) external returns (uint256) {
        _mint(msg.sender, _tokenId);
        _setTokenURI(_tokenId, uri);
        setApprovalForAll(contractAddress, true);
        return _tokenId;

    function resaleApproval(uint256 tokenId) public {
            ownerOf(tokenId) == msg.sender,
            "You must own this NFT in order to resell it"
        setApprovalForAll(contractAddress, true);

    function getTokenId() external view returns (uint256) {
        return _tokenId;

    // The following functions are overrides required by Solidity.

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal override(ERC721, ERC721Enumerable) {
        super._beforeTokenTransfer(from, to, tokenId);

    function _burn(uint256 tokenId)
        override(ERC721, ERC721URIStorage)

    function tokenURI(uint256 tokenId)
        override(ERC721, ERC721URIStorage)
        returns (string memory)
        return super.tokenURI(tokenId);

    function supportsInterface(bytes4 interfaceId)
        override(ERC721, ERC721Enumerable)
        returns (bool)
        return super.supportsInterface(interfaceId);


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";

contract MyNftMarket {
	struct Listing {
		address payable seller;
        address payable owner;
		address token;
		uint tokenId;
		uint price;
        bool sold;

	uint private _listingId = 0;
	mapping(uint => Listing) private _listings;

	function listToken(address token, uint tokenId, uint price) external {
		IERC721(token).transferFrom(msg.sender, address(this), tokenId);

		Listing memory listing = Listing(
		_listings[_listingId] = listing;


	function getListing(uint listingId) public view returns (Listing memory) {
		return _listings[listingId];

    function getListingLength()public view returns (uint){
        return _listingId;

	function buyToken(uint listingId) public payable {
		Listing storage listing = _listings[listingId];

		require(msg.value == listing.price, "Insufficient payment");

		IERC721(listing.token).transferFrom(listing.owner, msg.sender, listing.tokenId);

        listing.sold = true;
        listing.price = listing.price * 2;
        listing.owner = payable(msg.sender);
		listing.seller = payable(msg.sender);


Smart Contract Optimization

Optimizing the MyNFT Marketplace Smart Contracts

The provided MyNFT.sol and MyNftMarket.sol smart contract files serve as the foundation for your NFT marketplace. To ensure optimal performance, scalability, and gas efficiency, let’s explore several key areas where these contracts can be further optimized.

  1. MyNFT.sol Optimization:

a. Gas Efficiency:

  • In the mint function, consider replacing the usage of Counters.Counter with a simple uint256 variable to track token IDs. This can reduce gas costs by eliminating the need for the Counters library.
  • Instead of incrementing _tokenId with the ++ operator, consider using the _tokenIdCounter.increment() function from the Counters library, which provides optimized gas-efficient operations.

b. Event Emitting:

  • Emit events after each significant action, such as minting a new NFT or granting approval to the marketplace contract. Emitting events allows external applications to easily track and react to these events.

c. Safe Approvals:

  • Implement a check to avoid unnecessary approval calls in the mint function. Check if the NFT is already approved for the marketplace contract before calling setApprovalForAll. This avoids redundant approval calls and optimizes gas usage.

d. External Contract Initialization:

  • Consider implementing a separate initialization function for setting the contractAddress. This way, it can be updated if needed after deployment. Currently, it is set only during contract deployment and cannot be changed afterward.
  1. MyNftMarket.sol Optimization:

a. Mapping Storage:

  • Consider changing the _listings mapping from mapping(uint => Listing) private _listings; to mapping(uint => Listing) private _listings; to optimize storage costs. Using a mapping instead of an array allows for more efficient access to individual listings.

b. Struct Packing:

  • To minimize storage costs, consider packing the Listing struct more efficiently. Group smaller data types together to reduce padding and optimize storage usage.

c. Iterable Listings:

  • Consider adding an iterable data structure, such as an array or a mapping, to store and manage active listings. This will enable efficient iteration through active listings and provide an easy way to query the total number of listings.

d. Event Emitting:

  • Emit events for important marketplace actions, such as listing a token or completing a purchase. Emitting events allows external applications to stay updated with marketplace activities.

e. Handling Sold Listings:

  • Implement a mechanism to archive or remove sold listings from the active listings mapping or array. This optimization ensures that only active listings are stored, reducing storage requirements and improving overall efficiency.

These optimizations focus on improving gas efficiency, minimizing storage costs, and enhancing the overall performance of your NFT marketplace. Remember, optimization is an ongoing process, and it’s crucial to conduct thorough testing and audits to ensure the integrity and security of your smart contracts.

In the next section, we would guide you through deployment of your dApp to Netlify

Deploying a React App Implementing the MyNFT Smart Contract to Netlify

In this section, we will guide you through the process of deploying a React app that implements the MyNFT smart contract to Netlify, a popular platform for hosting static websites. By following these detailed instructions, you’ll be able to showcase your NFT marketplace to the world. Let’s get started!


  1. A React app set up with the MyNFT smart contract and its dependencies.
  2. An account on Netlify.

Step 1: Prepare the React App for Deployment

  1. Ensure that your React app is ready for deployment. Make sure you have a production-ready build by running npm run build or yarn build in your app’s root directory.
  2. Verify that your package.json file contains the correct dependencies and scripts needed for building and deploying your app.

Step 2: Create a New Netlify Site

  1. Open the Netlify dashboard (https://app.netlify.com) and log in to your account.
  2. Click on the “New site from Git” button to create a new site.
  3. Connect your Git repository by selecting your preferred Git provider and following the authentication process.
  4. Choose the repository where your React app code is located.
  5. Configure the build settings:
    • Set the “Build command” to npm run build or the appropriate command for your project.
    • Set the “Publish directory” to build.
    • Ensure that the “Install command” is npm install or yarn install.

Step 3: Configure Environment Variables

  1. In the Netlify dashboard, navigate to your newly created site’s “Settings” tab.
  2. Scroll down to the “Build & Deploy” section and click on “Environment variables”.
  3. Add any necessary environment variables for your React app, such as the Ethereum network provider URL, contract addresses, or API keys. Ensure they are prefixed with REACT_APP_ to be accessible within your app.
  4. Save the environment variables.

Step 4: Commit and Push Your Changes

  1. Make sure all your changes are committed and pushed to your Git repository.
  2. Netlify will automatically detect the changes and trigger a build and deployment process based on your


Step 5: Monitor the Deployment Process

  1. In the Netlify dashboard, go to your site’s “Deploys” tab.
  2. Monitor the progress of your deployment. Netlify will build your React app and deploy it to a unique URL.

Step 6: Test and Finalize

  1. Once the deployment process is complete, visit the provided URL to test and explore your NFT marketplace.
  2. Ensure that all functionalities, including NFT minting, listing, and purchasing, are working as expected.
  3. Make any necessary adjustments or bug fixes and repeat the deployment process if needed.


Congratulations! You have successfully deployed your React app, which implements the MyNFT smart contract, to Netlify. Your NFT marketplace is now accessible to users worldwide.

Throughout these NFT tutorials, we have delved into the fascinating world of NFT marketplaces, learning key concepts and exploring the steps involved in building, optimizing, and deploying one. Let’s summarize what we have covered:

  1. Understanding NFT Marketplaces:

    • Explored the concept of NFTs and their unique properties.
    • Discussed the role and significance of NFT marketplaces in the ecosystem.
    • Explored the benefits and potential use cases of NFT marketplaces.
  2. Building an NFT Marketplace Link:

    • Examined the necessary components of an NFT marketplace, such as smart contracts and a frontend application.
    • Explored the implementation of key functionalities, including NFT minting, listing, and purchasing.
    • Utilized popular frameworks and libraries like Solidity, React, and OpenZeppelin to simplify development.
  3. Optimizing Smart Contracts:

    • Analyzed the provided MyNFT.sol and MyNftMarket.sol smart contracts.
    • Identified areas for optimization, such as gas efficiency, event emitting, safe approvals, and struct packing.
    • Discussed best practices for improving contract performance and reducing storage costs.
  4. Optimizing the Frontend:

    • Highlighted the importance of optimizing the frontend application for better user experience and performance.
    • Covered techniques like lazy loading, code splitting, and image optimization to enhance frontend efficiency.
    • Emphasized the significance of responsive design, intuitive user interfaces, and smooth interactions.
  5. Deploying the NFT Marketplace:

    • Explored the process of deploying a React app implementing the MyNFT smart contract to Netlify.
    • Outlined the steps for preparing the app, configuring environment variables, integrating build hooks, and monitoring the deployment process.

By assimilating the knowledge gained from this tutorial, you are now equipped with the necessary understanding and skills to create, optimize, and deploy your own NFT marketplace. Whether you are venturing into the world of digital art, collectibles, gaming assets, or any other NFT-related domain, you have the tools to transform your ideas into reality.

Remember to stay up to date with the latest developments in the NFT space, as the technology and market trends continue to evolve rapidly. Regularly review and enhance your smart contracts, frontend applications, and deployment strategies to ensure optimal performance and adaptability.

TIll we see again! Bye

About The Author

Daniel Ogbuti is a web3 developer with a passion for teaching as well as learning. I would love to connect on Twitter @daniel_ogbuti and linkedin: Daniel Ogbuti

See you soon!


looking forward to implementation boss!


Great idea


Looking forward to this article


Will love this

Fantastic news! Your proposal has landed in this week’s top voted list. As you begin your project journey, remember to align with our community and technical guidelines, ensuring a high quality platform for our developers. Congratulations! :mortar_board: :seedling:

1 Like

I will be reviewing this

1 Like