For a JSP application, the correct deploy path is usually the web application root used by your Tomcat instance, not the public HTML directory of the hosting account. In a Plesk-based Java hosting setup with My App Server, that means you should deploy your application into the document root or application directory configured for the specific Tomcat instance and context path, so the server can load the JSP files, servlets, classes, and web resources correctly.
If you upload JSP files to the wrong location, the application may not start, pages may return 404 errors, or Tomcat may not compile the JSP files as expected. The exact deploy path depends on how your app server is configured, whether you are using a WAR package, an expanded web application directory, or a custom application path set in Plesk.
What deploy path should you use?
In most JSP hosting environments, the deploy path should point to the web application root. This is the folder that contains the application structure, such as WEB-INF, JSP pages, static assets, and configuration files.
Typical deployment options include:
- WAR upload — deploy the application as a
.warfile to the app server’s deploy area. - Expanded web app folder — upload the extracted application files to the configured web root for that app.
- Context-specific path — use the path assigned in Plesk or My App Server for that Java application.
If you are using ITA’s My App Server, the deploy path is generally the app-specific directory managed by the extension, not the standard website directory used for PHP or static websites. This helps keep the Tomcat application isolated and easier to manage.
How JSP deployment works in Tomcat and Plesk
JSP pages are processed by Tomcat as part of a Java web application. Tomcat expects a standard application structure, usually based on the Servlet specification. That means it must be able to find the app root, the WEB-INF folder, and any compiled or configured resources.
In a managed hosting environment with Plesk and My App Server, the deployment flow is usually:
- You select or create a Java/Tomcat application in Plesk.
- You choose the Java version and Tomcat version if supported.
- You upload a WAR file or place the application files in the configured deploy directory.
- The app server deploys the application and maps it to a context path.
- Your JSP pages become accessible through the application URL.
This is different from a plain website upload, where files are placed directly into a public document root. JSP applications should be deployed in the app server’s managed location so Tomcat can handle compilation, session management, servlet mapping, and resource loading properly.
Recommended deploy paths by deployment type
1. WAR file deployment
If your application is packaged as a WAR file, upload it to the deploy location defined by your app server in Plesk. In many Tomcat setups, this is the monitored deployment directory or the application upload area associated with the selected instance.
Use this method when:
- You have a complete Java web application package.
- You want Tomcat to expand and deploy the app automatically.
- You are redeploying a tested release build.
Do not place the WAR file in a generic website folder unless your hosting setup explicitly documents that location as the Tomcat deploy path.
2. Expanded application directory
If you upload an unpacked application, the deploy path should be the application root directory, containing the standard Java web structure. A typical layout looks like this:
WEB-INF/WEB-INF/web.xmlWEB-INF/classes/WEB-INF/lib/jspfiles- static files such as CSS, images, and JavaScript
The important part is that the application root is the directory Tomcat recognizes as the web app base. If the structure is nested too deeply, JSPs may not resolve correctly and the context path can be wrong.
3. Custom app server path
Some hosting accounts allow a custom app server path through the control panel. In that case, the correct deploy path is the one configured in the My App Server interface or related Plesk extension page.
This is useful if you manage multiple Java apps in one account, because each app can have its own:
- Tomcat instance
- Java version
- application path
- service control settings
When a custom app path is used, always follow the path shown in the control panel rather than guessing the folder based on domain name alone.
How to find the correct deploy path in Plesk
To avoid deployment errors, check the app path in the control panel before uploading files. In a managed Java hosting setup, the deploy path is usually visible in the My App Server or Java application configuration screen.
Look for fields such as:
- Application path
- Context path
- Deploy directory
- Document root for the Java app
- WAR deployment location
If the interface lets you choose the path, keep the structure simple and consistent. For example, use one app per directory and avoid placing unrelated files in the same location.
If you are unsure, compare the deploy path with the domain or subdomain that will serve the application. The app server usually maps the app to a URL like /myapp or to the root of a dedicated subdomain.
Best practices for JSP deploy paths
Choosing the right deploy path is not only about making the app start. It also affects maintainability, version control, and troubleshooting. These practices help keep JSP hosting clean and predictable.
Use one application root per app
Do not mix multiple applications in one folder. Each JSP application should have its own root directory or WAR package. This prevents file conflicts and makes updates easier.
Keep WEB-INF protected
Everything inside WEB-INF should remain inaccessible directly from the browser. Tomcat uses this folder for configuration, classes, and libraries. If your app structure exposes it incorrectly, the application is likely deployed in the wrong path.
Match the deploy path to the context path
The deploy path on disk and the URL context path are related but not identical. For example, your files may live in a managed directory, while the app is served at /shop. Make sure you know both values when debugging a JSP hosting issue.
Do not upload JSP files to the public site root unless instructed
On shared hosting, the standard website folder may be intended for static content or another stack. JSP files need Tomcat processing, so they should be deployed through the Java app service, not just copied into the site root.
Keep the path stable between deployments
Frequent path changes can break links, session handling, and deployment scripts. If possible, use a fixed application directory and only update the content inside it.
Example deployment scenarios
Scenario 1: You have a WAR file
Upload myapp.war to the deployment area assigned by My App Server in Plesk. Tomcat extracts the WAR and makes the application available at the mapped URL. This is usually the simplest option for JSP hosting.
Scenario 2: You have source files and JSP pages
Place the application in the configured app directory. Make sure the root contains WEB-INF and the JSP pages are in the correct locations. Uploading only the .jsp files without the rest of the structure is usually not enough for a working application.
Scenario 3: You are updating an existing app
Replace the contents of the existing app path with the new version, or deploy a new WAR to the same managed location. Keep backups before changing live files, especially if the application stores configuration locally.
Common mistakes when choosing a deploy path
Many JSP deployment issues are caused by a wrong folder choice rather than a problem in the code itself. The most common mistakes are:
- Uploading JSP files to the wrong directory.
- Placing application files outside the Tomcat-managed path.
- Missing the
WEB-INFfolder or using an incorrect structure. - Confusing the URL path with the file system path.
- Deploying to a path used by another application.
- Using a static web root instead of the app server deploy root.
If the app returns a 404 error after upload, first verify whether the files are in the exact deploy path expected by the app server. If Tomcat cannot see the app root, it cannot deploy the application correctly.
How deploy path affects JSP and servlet behavior
The deploy path influences how Tomcat loads classes, resolves JSP includes, reads configuration, and serves resources. A correct app root ensures:
- JSP pages compile properly.
- Servlet mappings work as expected.
- Libraries in
WEB-INF/libare loaded. - Application resources are found without path errors.
- Sessions and relative links behave consistently.
In private JVM or shared Tomcat hosting, this is especially important because the hosting control panel often manages multiple services and app instances. Using the correct deploy path keeps the Java application isolated and easier to restart, update, or troubleshoot.
Quick checklist before you deploy
- Confirm whether you are deploying a WAR or an expanded app directory.
- Check the application path shown in Plesk or My App Server.
- Verify that
WEB-INFexists in the correct location. - Make sure the app root is not inside another unrelated folder.
- Ensure the Java version and Tomcat version match your application requirements.
- Restart or redeploy the app if the control panel requires it.
- Test the context path in the browser after upload.
Troubleshooting deployment path issues
If your JSP application does not load after deployment, use this sequence:
- Check the exact deploy directory in Plesk.
- Confirm that the app files were uploaded into that path.
- Verify the application structure and the presence of
WEB-INF. - Look for deployment or service status in My App Server.
- Restart the service if your hosting plan supports it.
- Review any logs available through the control panel.
In many cases, the issue is simply that the application was placed in the wrong folder. Fixing the path and redeploying usually resolves the problem quickly.
Frequently asked questions
Should I upload JSP files to the public website folder?
No, not unless your hosting provider specifically says that folder is the Tomcat deploy path. JSP files should normally be deployed through the Java application root managed by Tomcat.
Is the deploy path the same as the URL?
Not always. The file system deploy path is where the app lives on the server. The URL or context path is the address visitors use in the browser. They are related, but they are not the same thing.
What is the safest choice for a JSP application?
The safest choice is to use the app server’s managed deployment location in Plesk, especially when using My App Server. That ensures Tomcat can handle the application correctly.
Can I deploy both JSP and servlet code in the same path?
Yes. A JSP application often includes JSP pages, servlets, classes, libraries, and static files in one web application root. They should all sit under the same managed app directory or WAR package.
What if I need a different Java version?
Choose the Java version configured for the application in My App Server before deploying. The deploy path stays the same, but the runtime version must match your application requirements.
Why does my app work locally but not after upload?
Common reasons include an incorrect deploy path, missing files, wrong folder structure, or a mismatch between the app’s expected context and the server configuration.
Conclusion
For a JSP application, use the Tomcat-managed application root or the deploy directory configured in Plesk through My App Server. Do not rely on a generic public folder unless it is explicitly mapped as the Java app path. The correct deploy path ensures Tomcat can process JSP pages, load servlets and libraries, and serve the application under the right context.
If you are managing Java hosting in a Plesk environment, the best approach is to follow the application path shown in the control panel, keep the app structure standard, and deploy through the managed Tomcat service. That gives you the cleanest setup for JSP hosting, servlet hosting, and small to medium Java applications.