Recommendations

Our platform automatically detects the language and framework of your project to build and deploy it with zero configuration from your side.

To help ensure your app is detected and deployed smoothly, we recommend the following best practices depending on the technology you’re using.

General Repository Structure

• Your source code should be located at the root of the repository.

• Include the main configuration or manifest file (e.g., package.json, requirements.txt, pom.xml, etc.).

• Avoid empty folders or including multiple apps in the same repo (monorepos are currently not supported).

• Add a proper .gitignore file for your stack.

Supported Technologies & Implementation Tips

• Ensure your package.json includes proper build and/or start scripts.

• Common frameworks supported:

  • React: use vite, react-scripts, or Next.js for SSR/SPA.

  • Vue: use Vite or Vue CLI. Ensure vite.config.ts or vue.config.js is present.

  • Angular: include angular.json and make sure ng build works correctly.

  • Next.js, Astro, Remix, SvelteKit: include framework-specific config files.

• Specify a custom output directory in the config file if it differs from the default (dist, .next, etc.).

• Dependencies should be up to date and installed correctly.

Static Frontend Sites (HTML/CSS/JS)

• Use standard output folders like dist or build.

• Frameworks like Vite, Astro, or SvelteKit must define their output directory in their config.

• Static apps must include a valid index.html in the output.

Java / Spring Boot

• Include pom.xml (Maven) or build.gradle (Gradle) in the root.

• Use a single main class annotated with @SpringBootApplication.

• Build output should be an executable JAR (java -jar ready).

• Avoid untracked runtime dependencies or complex local configs.

Python

• Include a requirements.txt or pyproject.toml in the root.

• For Flask, Django, or FastAPI, clearly define the entry point (app.py, main.py, etc.).

• Use gunicorn or another WSGI server in production.

• Avoid custom non-standard folder structures.

Go

• Place your main.go file in the root or a clearly named subfolder.

• Ensure go.mod is included and valid.

• Use go build to produce a single binary.

• For web apps, expose the service using a standard HTTP server like net/http.

Rust

• Include a valid Cargo.toml file at the root.

• The main application should be inside the src directory.

• Use cargo build --release to produce the binary.

• Web apps using frameworks like actix-web or rocket are supported if they expose an HTTP server.

Best Practices

• Avoid interactive prompts or complex scripts during install or start.

• Make sure your app doesn’t depend on non-versioned external tools or configs.

• Stick to well-supported and stable versions of your language/framework.

Avoid These Pitfalls

• Empty or documentation-only repositories.

• Incomplete projects without build/start scripts.

• Unusual or overly nested folder structures.

• IDE-specific or environment-specific files/configs.

What if My Project Isn't Detected?

If your app isn’t detected or deployed:

• Double-check that it follows the expected structure described above.

• Make sure necessary config files are present.

• Ensure there are no missing scripts or unsupported edge cases.

Still having trouble? Reach out to our support team — we’re here to help you get deployed!