THE DEVELOPER FIELD GUIDE
Build the thing.Know the next step.
Practical paths through deployment, data and release management. Start with the task in front of you, then go deeper where it matters.
Start free with up to five projects. Review capacity and compatibility before you grow.
Static output, server framework or HTTP application.
Source, build and publication each have their own output.
Test a route and the identity behind its data request.
Practical guides backed by Fortly’s current deployment and data documentation
Find the guide that matches your task.
The first hosting question is often smaller than “which platform is best?” It might be how to deploy a repo, why a build failed, or how a frontend should read a table. These guides begin at that task and carry the context forward: source, runtime, identity, release and the result a visitor should see.
8 starting points
Deploy an app from a monorepo
Choose a supported source path, keep workspace dependencies intact and verify the right application.
Explore Storage guideBuild a private upload workflow
Connect a bucket, authorize app users, issue temporary downloads and plan shared capacity.
Explore Deployment guideDeploy a GitHub repository
Prepare the repo, review variables, ship a branch, verify the app and make the next push predictable.
ExploreTroubleshooting guideFind the failing deployment stage
Separate a platform connection problem from install, compilation, publication and runtime failures.
ExploreFramework guideShip a Next.js app
Choose SSR or static output, configure public build values and plan HTTPS data access.
ExploreRuntime guideCheck your HTTP app’s runtime
Make an Express or fetch-handler entry point clear and review Worker compatibility before migrating.
ExploreStatic site guidePublish a static site
Understand output directories, archive roots, direct URL tests and SPA versus multi-page routing.
ExploreData guideConnect tables and API access
Choose the caller identity, review grants, test a request and plan database exports.
ExploreNo match yet. Try “deploy”, “static” or “database”, or open the full documentation.
A few good paths through the product.
A first idea, from your laptop
Begin with a page or small app you can already run locally. Decide whether its output is static or needs a server. Use the matching hosting page to check the runtime, then upload an archive or connect a repository. A successful build is a milestone; opening the public URL and exercising the intended route is the verification.
An existing application, moving hosts
Inventory more than the source files. Record the framework, build command, output, environment values, database access, file storage and provider-specific services. Match each dependency to a documented Fortly path. A new frontend build cannot recreate an external database or a provider-specific backend simply because the original app once deployed successfully.
A live app, with a change to ship
Keep the current release in view. Review the new source and variables, follow the selected release’s build output, and verify the published app with a real route and data request. If a build fails, read its first meaningful error. If a build succeeds but a request fails, switch to runtime and access diagnostics rather than repeatedly changing the build.
Use the right depth of explanation.
Start with a guide to decide and complete a task. Open the linked documentation when you need the exact contract: request fields, response shapes, current limits, framework conditions and the consequences of an operation.
| Your question | Start here | Then use |
|---|---|---|
| Will my application fit? | The hosting page for its workload | Build compatibility and migration documentation |
| How do I make a first release? | The GitHub deployment guide | Quickstart and deployment API reference |
| Why did this release fail? | The failed-deployment guide | Release-specific logs and troubleshooting docs |
| Who can read these rows? | The PostgreSQL overview | Frontend API, app-user identity and row-policy docs |
For a Next.js application, check build variables before compilation and data access before testing a route. For a failed build, follow the selected release output before inspecting runtime logs. For a database, review the actual grant and export behavior before planning production use. Each path below connects the decision to its implementation reference.
What a useful guide should leave you with.
After a deployment guide, you should know what source was deployed, which branch or archive it came from, where its output is recorded and how to verify the public application. After a data guide, you should know who the caller is and which operations the key or identity can perform. After a troubleshooting guide, you should have a specific next action, not another unexplained retry.
Examples here use clearly labelled sample projects and records. They do not create projects or change your account. Commands that need your project name or token say so; browser-facing examples use publishable access only when the required grants have been reviewed. Use the current documentation for the precise limits before planning a production workload.
If the guide gets you to a question about your own project, contact the Fortly team with the project URL, the relevant release and the first meaningful error. That is enough context to start a useful conversation without reproducing your entire application in a message.
Before you build
A few useful answers.
Are these the API reference?
These pages explain tasks and hosting decisions. The linked documentation carries the complete API routes, limits and compatibility requirements.
Can I follow the examples without a project?
The previews and checklists work locally in this page. Deploying your own code or executing API requests requires a Fortly account and your own project details.