# Building dApps with Nyvo: Step-by-Step Guide

Nyvo is designed to make the dApp development workflow simple for experienced developers by automating setup and providing sensible defaults. Below is a step-by-step guide to building a decentralized application using Nyvo:

{% stepper %}
{% step %}
**Define the dApp Prompt**

Begin by describing your desired application through Nyvo’s interface. Nyvo accepts a natural language prompt that captures the utility and features of your dApp (and optionally styling preferences). For example, the figure below shows Nyvo’s web UI with a prompt to *“Create a crypto launchpad for Solana memecoins with a bonding mechanism”*. This prompt instructs Nyvo to scaffold a Launchpad module tailored for token sales with a bonding curve. The Nyvo backend uses AI to interpret the prompt and determine the appropriate smart contract templates, parameters, and UI components required.
{% endstep %}

{% step %}
**Configuration & Module Selection**

Once the prompt is processed, Nyvo will present a generated dApp blueprint. As a developer, you can configure the specifics at this stage. This includes selecting the dApp type/module (Nyvo might auto-select one based on the prompt, which you can confirm or adjust), and setting parameters for that module.&#x20;

For instance, if you’re building a staking platform, you might configure the reward rate or staking token; for a marketplace, you could set whether it’s an NFT marketplace or fungible token exchange. Nyvo’s interface will list the modules (staking, marketplace, launchpad, governance, etc.) relevant to your prompt. You may also choose the Solana cluster for deployment (devnet for testing or mainnet-beta for production). This step is crucial for tailoring the dApp’s logic – essentially, you are providing inputs to Nyvo’s internal API so it can instantiate the smart contracts with your desired settings.
{% endstep %}

{% step %}
**Program Generation and Deployment**

After configuration, Nyvo generates the Solana program code for your dApp and handles its deployment. The platform’s cloud service will compile the program (e.g. using Rust and Anchor, behind the scenes) and prepare the deployment transaction. You will then be prompted to connect your wallet (e.g. Phantom) and approve the deployment. Nyvo uses your wallet as the fee payer and optionally as the program’s upgrade authority. When you approve, the program bytecode is uploaded on-chain as a BPF program. This transaction may consist of multiple instructions (such as allocating the program account, writing the program data, and finalizing it), but Nyvo batches these into one workflow so you only sign once.&#x20;

The Solana runtime charges a small fee based on transaction size and signatures (5000 lamports per signature). Nyvo will ensure the new program is funded with enough lamports to cover rent-exempt storage (Solana requires 2 years of rent paid upfront for account storage). This means if the program’s account is, say, *N* bytes, Nyvo will deposit roughly `(N + 128) * 6,960` lamports to make it rent-exempt (128 bytes is account overhead). Deployment is complete when you receive a program ID – a 32-byte address representing your on-chain dApp logic.
{% endstep %}

{% step %}
**Front-End Generation and Binding**

With the back-end program deployed, Nyvo now generates a front-end application that interacts with it. Nyvo’s front-end generator produces a web application (likely in React/TypeScript) that includes UI components for your chosen modules. This includes wallet connection widgets, forms and buttons for each on-chain action, and dynamic displays of on-chain data. The front-end is pre-configured with the program ID and uses Nyvo’s runtime library or Solana’s web3 SDK to call into the program.&#x20;

For example, if your dApp is a marketplace, the generated UI will have a listing view and purchase buttons, and the code behind those buttons will invoke the marketplace program’s instruction (via `solanaWeb3.js` or an Anchor client). All the heavy lifting – constructing transactions, encoding instruction data, addressing the correct program accounts – is handled by the Nyvo API layer in the front-end. Developers can customize the UI layout or styling further, but the core logic connecting to Solana is already in place. Nyvo may either provide the front-end as a downloadable code package or host it for you at a temporary URL. In either case, you should review it for any tweaks needed (for instance, inserting your branding or adjusting text).
{% endstep %}

{% step %}
**Testing the dApp**

Before releasing, it’s critical to test your Nyvo-built dApp. If you deployed to Solana’s *devnet*, you can use that environment for testing without real funds. Use a wallet with devnet SOL (Nyvo might automatically airdrop some for you, or you can use Solana CLI to request an airdrop) to simulate user interactions. Test all module features: e.g., for staking, try staking and unstaking flows; for a launchpad, run through a token sale round on devnet. Observe the on-chain state changes using explorers or the Nyvo developer console (Nyvo may provide a dashboard showing account data). Nyvo’s front-end likely has logging or developer mode to see the transactions being sent.&#x20;

You can also utilize Solana’s transaction simulation feature to predict outcomes without committing state. The Solana RPC method `simulateTransaction` allows you to run a transaction locally on a node and get the result and logs, which is useful for debugging Nyvo’s tools might expose a one-click “Simulate” for any user action, enabling you to see if a transaction would succeed (and how much compute it would consume) before actually sending it. Make sure to test edge cases (e.g., error conditions like trying to buy an item with insufficient balance) to ensure the dApp handles them gracefully (the UI should display transaction errors returned by the program).
{% endstep %}

{% step %}
**Deployment to Production**

Once satisfied with testing, you can deploy the dApp to Solana mainnet-beta. Nyvo can repeat the program deployment on mainnet (or if the program was upgradeable and you kept upgrade authority, simply upgrade it).&#x20;

Ensure your wallet has enough SOL to fund the deployment (program deployments are larger transactions; expect maybe on the order of \~0.5–1 SOL for a complex program when including rent deposit). After deployment, update the front-end to point to the mainnet program ID and RPC endpoint. If Nyvo hosts the front-end, you will switch the environment to mainnet; if you manage the front-end code, build and host it on your own domain or a service (Nyvo might offer hosting or you can use platforms like Vercel, Netlify, etc.).&#x20;

Finally, connect your custom domain or share the dApp URL with users. As users begin to use the dApp, monitor the application’s performance and Solana network fees. Solana’s fees are very low per transaction (usually fractions of a cent), but if your dApp gains heavy usage, ensure you have a strategy (perhaps instructing users to set a priority fee during congestion, see Fee Model below). Nyvo’s architecture will handle scale automatically, as Solana can process a large number of transactions per second and Nyvo’s programs are optimized for high throughput.
{% endstep %}
{% endstepper %}
