Prototype your next idea with Ampt

Today's tech scene is a mix of challenges and opportunities. With the ups and downs in tech jobs and the rise of AI apps, many are inspired to chase their big ideas. For new startups, quickly turning an idea into a testable experiment and getting real feedback is a game changer. However, decision paralysis on which cloud services, database technologies, or development approach to use causes teams to lose their pace and waste lots of time on things that don’t ultimately add value to their potential customers.

The endless number of choices, coupled with the steep learning curve of orchestrating multiple cloud services, discourages developers from turning their idea into a reality. Self-provisioning runtimes are a new concept in which the runtime analyzes your application code, identifies the required cloud resources, and provisions them automatically. They also incorporate ongoing management capabilities by securing and optimizing those resources over time. Developers can shed the mental burden of managing this undifferentiated heavy lifting themselves and focus on shipping their ideas as quickly as possible.

This post will show you how Ampt lets developers do just that: learn how to rapidly build full-featured apps using Node.js with popular frameworks like Next.js, React, SvelteKit, Vue, and more.

Everything a builder needs

Ampt is designed to support a modern cloud developer’s needs. With drop-in support for most popular full stack frameworks like Next.js, Remix, and Astro, developers can utilize the skills they already have to build with Ampt. Beyond framework compatibility, it also offers built-in interfaces for database integration, file storage, CDNs, events, secure parameters, and long-running tasks, streamlining the development process. In just a few lines of code, you can build asynchronous workflows using Ampt’s event-driven approach.

Here's a basic example demonstrating how to set up an asynchronous CSV parser using Express.js on Ampt:

javascriptCopy code
import { http, storage } from '@ampt/sdk';
import express, { Router } from 'express';
import data from '@ampt/data';
import Papa from 'papaparse';
import multer from 'multer';

const multipartFormLoader = multer({ storage: multer.memoryStorage() }).any();
const app = express();
app.use(multipartFormLoader);

const publicApi = Router();
const csvStorage = storage('csvs');

// Create upload post route
publicApi.post('/csv', async (req, res) => {
  try {
    const delimiter = ',';
    if (!req.files || !req.files.length) {
      console.log('in the if!!');
      return res.status(400).send('No files were uploaded.');
    }
    const buffer = req.files[0].buffer;
    const filename = req.files[0].originalname;
    const writeResponse = await csvStorage.write(filename, buffer, {
      metadata: { delimiter },
    });
    return res.json(writeResponse);
  } catch (err) {
    res.status(500).send(err);
  }
});

// Add storage listener
csvStorage.on('write:*.csv', async (event) => {
  try {
    const { path } = event;
    const { metadata } = await csvStorage.stat(path);
    const delimiter = metadata.delimiter || ',';
    const buffer = await csvStorage.readBuffer(path);
    const csvString = buffer.toString('utf-8');
    const csv = Papa.parse(csvString, {
      header: true,
      delimiter,
    });

    if (csv.data.length) {
      await Promise.all(
        csv.data.map((row) => {
          const id = row['$distinct_id'];
          const firstName = row['$name'];
          const email = row['$email'];
          return data.set(`customer:${id}`, {
            id,
            firstName,
            email,
          });
        })
      );
    }
  } catch (e) {
    console.error(e);
  }
});

// Register the router
app.use('/api', publicApi);

// Expose the app to the CDN
http.node.use(app);

We set up a standard Express.js API endpoint to upload and store a file, followed by an asynchronous event handler to process the CSV file that writes its records to the built-in datastore. There’s no need to write complex configuration files, deploy cloud resources, or figure out how to set up event-driven workflows. This code focuses solely on your core business logic while Ampt automatically manages the provisioning and configuration of the necessary cloud resources on AWS. This approach dramatically increases developer efficiency, reduces cognitive overhead, and fast-tracks the entire development cycle.

Reynaldo Reyna, who leads a cloud consulting firm and has utilized Ampt for numerous client projects, attests to its impact:

Integrating with Your Favorite Framework

Prototypes aren't solely about what's under the hood. An engaging user interface plays an important role in captivating your target audience right from the get-go. Whether you're using full stack SSR frameworks like Next.js, Remix, or Astro, creating Single Page Applications (SPAs) using React or Vue, or building static sites (SSGs) with Eleventy, Ampt makes the integration incredibly simple. All you need to do is to define your build scripts in your package.json file.

Ampt automatically integrates the local development server of your framework in the Ampt CLI. Just run dev while you’re in Ampt CLI and the development server of the framework you’re using will run within the Ampt Shell. This boosts productivity while working with full stack applications by integrating the frontend and backend development experience, giving you lightning fast feedback loops. Once you try it, you’ll never want to go back to the old way of doing things. Check out the documentation for Next.js, Remix, Astro, SvelteKit and SPAs like React and Vue.

Build, Share, Learn, Repeat!

Shipping quickly isn't just about speed—it's also about getting feedback as quickly as possible. Rapid iteration, based on user and stakeholder insights, is crucial to refine your product and better resonate with target users. Ampt offers adaptable workflows, enabling developers to effortlessly present varying versions of their apps to different types of stakeholders.

The process is simple: just create a pull request. With Ampt's GitHub integration, new pull requests are detected and can automatically trigger the creation of preview environments. Easily share the unique ampt.app URL with your stakeholders and gather feedback even as you continue to develop in your isolated developer sandbox. Each PR gets its own separate preview environment and will automatically redeploy if you commit additional changes. You can also use the Ampt CLI’s share command to manually create preview environments directly from your sandbox.

When you’re ready to share your work with the world, simply merge PRs to your main branch. Ampt will automatically create a production deployment for your full stack application. You can even assign a custom domain to your production environment.

Getting Ahead with Rapid Prototyping Using Ampt

In these hyper-competitive times, getting to market faster than your competitor is no longer just an advantage—it's essential. Being able to rapidly deliver prototypes into the hands of potential customers puts you one step ahead of the competition. Ampt stands out as the top choice for your prototyping needs.

While prototyping quickly is certainly a major draw, Ampt is backed by the full power of AWS Cloud’s native services and was designed to support your high-scale production workloads. Many users start by quickly building prototypes, then discover the convenience and adaptability Ampt brings. This ultimately leads them to use it to manage and scale their production projects.

James Hammond, a regular Ampt user, shares:

Sign up to start building now with Ampt! Also, be sure to join us on Discord to engage with our vibrant community of Node.js and JavaScript developers.