When you upload JSP application files through Plesk or FTP, the main goal is to place your web application in the correct deploy path so Tomcat can read it and compile the JSP pages properly. In a Java hosting environment with Plesk, this usually means copying your application package or expanded web app into the folder mapped to your domain or app server service.
If you are using a managed hosting account with a private Tomcat instance or a service such as My App Server, file placement matters just as much as the Java version and the service status. A correctly uploaded JSP application can still fail to run if it is stored in the wrong directory, has incorrect permissions, or is deployed before the service is ready.
Where JSP application files should be uploaded
The exact folder depends on how your hosting account and Tomcat instance are configured, but the basic rule is simple: upload the application files to the document root or deploy path assigned to your JSP application.
In a typical Plesk-based Java hosting setup, you may work with one of these deployment patterns:
- Expanded application directory — your JSP, HTML, XML, class, and resource files are uploaded into the application folder directly.
- WAR package deployment — you upload a .war file, and Tomcat deploys it automatically.
- Custom deploy path — the application is placed in a specific directory defined in the Plesk extension or service settings.
If your service uses the My App Server extension, the deploy path is typically linked to the app server configuration in Plesk. That means the same account can host multiple Java or JSP applications, each with its own folder and service settings.
Common folder examples
Although folder names may vary from one hosting account to another, you may see paths similar to these:
/httpdocs/for a website root/httpdocs/yourapp/for an application in a subfolder/var/www/vhosts/example.com/for the account root in some Plesk layouts- a Tomcat-specific application directory managed by the app server extension
Always follow the deploy path shown in Plesk or in your hosting documentation. Uploading JSP files to the wrong location is one of the most common reasons why a page returns a 404, a blank screen, or a server-side error.
Upload JSP files through Plesk File Manager
Plesk File Manager is the easiest way to upload a JSP application if your package is small or if you need to make a quick change. It is useful for static resources, JSP pages, configuration files, and smaller web application updates.
Steps to upload through Plesk
- Log in to Plesk.
- Open the relevant domain or subscription.
- Go to Files or File Manager.
- Navigate to the deploy path for your JSP application.
- Click Upload.
- Select your files or a compressed archive.
- Wait for the upload to complete.
- Extract the archive if needed, then verify the final folder structure.
If your application is a WAR file and your hosting plan supports deployment from Plesk, upload the WAR package to the designated folder or use the app server interface if available. Some hosting setups automatically deploy WAR files when they are placed in the application directory.
When File Manager is the best option
- You need to upload a small set of JSP or HTML files.
- You want to replace a single configuration file.
- You need to inspect the folder structure before deploying.
- You are testing a new version of the application.
For larger packages, FTP is usually faster and more practical.
Upload JSP application files through FTP
FTP is the preferred method for full application uploads, especially when you are deploying an expanded Java web app with many files. It gives you more control over directory structure and is usually better for repeated updates.
Before you start
You will need the following FTP details from your hosting account:
- FTP host name
- FTP username
- FTP password
- FTP port, if your provider uses a custom one
- the correct remote directory for your JSP app
You can use any standard FTP client, such as FileZilla or another client supported by your workflow. In many cases, SFTP may also be available and is preferred when supported, because it provides encrypted file transfer.
FTP upload steps
- Open your FTP client and connect to the account.
- Go to the application deploy directory.
- Open the local folder that contains your JSP application files.
- Upload the files and folders while preserving the structure.
- Check that JSP, WEB-INF, classes, libraries, and resource files are in the right places.
- Wait until all files are transferred completely.
- Refresh the application in your browser and verify the result.
If you are uploading a full Tomcat web application, do not flatten the folder structure. JSP pages, the WEB-INF directory, compiled classes, and dependency JAR files must stay in the correct locations for the application to work.
Upload a WAR file or an expanded web application
JSP applications are often deployed in one of two ways: as a WAR archive or as an expanded directory. Both methods are common in Tomcat hosting and can be supported in a Plesk-managed environment, depending on your configuration.
Uploading a WAR file
A WAR file is a packaged Java web application. It is convenient when you want to deploy a complete app in one file.
- Upload the
.warfile to the deploy path or application folder. - Use Plesk or the My App Server interface to trigger deployment if required.
- Wait for Tomcat to unpack and publish the app.
- Test the application URL after deployment.
This method is useful when your application is built by a CI process or exported from a local IDE.
Uploading an expanded application
An expanded application means the web app is already unpacked into folders and files. This approach is useful when you want to update a single JSP file, edit a view, or modify resources without repackaging everything.
- Upload the full folder structure to the assigned deploy directory.
- Keep the
WEB-INFfolder protected from direct browser access. - Make sure all library JAR files are placed in the correct subfolder.
- Confirm that file names match the application configuration exactly.
For JSP hosting, the expanded deployment model is often convenient for day-to-day file management and smaller application changes.
How to keep the correct folder structure
A JSP application depends on a precise directory layout. Even if the files are uploaded successfully, the app may fail if the structure is incorrect.
Typical JSP web app structure
index.jspor another entry JSP in the web rootWEB-INF/for protected configurationWEB-INF/web.xmlif your application uses a deployment descriptorWEB-INF/classes/for compiled Java classesWEB-INF/lib/for dependency JAR filesassets/,css/,js/, or other resource folders
Do not place application files randomly at the top level unless that is the structure expected by your app server. For example, uploading all files one folder too deep can create an extra path segment in the URL and break routing.
Common structure mistakes
- Uploading the whole project folder instead of its contents
- Putting JSP files inside
WEB-INFby mistake - Leaving the WAR archive nested inside another folder
- Renaming files in a way that breaks case-sensitive paths
- Forgetting to upload dependency JARs
These issues are especially important in Linux-based hosting environments, where file names are case-sensitive.
Permissions and ownership after upload
Correct file permissions are essential for JSP application deployment. Tomcat must be able to read the files, and in some cases write temporary data or logs depending on the setup.
Practical permission guidance
- Application files should normally be readable by the web server and Tomcat process.
- Do not make application files world-writable unless your hosting provider instructs you to do so.
- Make sure uploaded files preserve the intended ownership set by the hosting platform.
- If you use FTP, verify that the transfer did not change permissions unexpectedly.
If your application fails after upload, permission problems are often one of the first things to check. Symptoms may include 403 errors, deployment failures, or missing resource files.
Deployment with My App Server and Plesk
In a managed Java hosting environment, the upload process is often connected to a hosting control panel extension such as My App Server. This gives you a practical way to manage a private JVM or private Tomcat instance within your hosting account.
With this approach, you can usually:
- select a Java version for the app server
- start or stop the service from Plesk
- review the deploy path assigned to the application
- upload JSP, WAR, or supporting files to the proper location
- restart the app server after file changes if needed
This setup is well suited to small and medium JSP, servlet, and Tomcat-based applications that need more control than basic shared hosting, but do not require complex enterprise clustering or heavy platform management.
Best practice after deploying files
- Confirm that the app server service is running.
- Check that the files are in the expected deploy path.
- Review logs if the application does not start.
- Refresh the application URL after any restart or redeploy.
- Clear browser cache if you are testing updated JSP pages.
Troubleshooting common upload and deploy problems
If your JSP application does not work after upload, the issue is often not the upload itself but the deployment path, structure, or service state.
File upload completed, but the app is not visible
Check the following:
- the files are in the correct directory
- the domain points to the right document root or app path
- Tomcat or My App Server is running
- the application name matches the URL path
JSP pages show an error or do not compile
Possible causes include:
- missing libraries in
WEB-INF/lib - wrong Java version selected in the service
- syntax errors in the JSP or Java code
- incorrect file permissions
- incompatible Servlet or JSP API usage
Uploaded files appear in the wrong folder
This usually happens when the local project folder is uploaded instead of its contents, or when the FTP client creates an extra directory level. Open the remote folder carefully and confirm the application root before transferring files again.
Deployment works locally but not on the hosting account
Review the hosting-specific requirements:
- supported Java version
- Tomcat version selected in Plesk
- service limits defined for the account
- deploy path and naming rules
- log output from the app server
In managed hosting, a simple mismatch in Java version or path configuration can prevent deployment even when the application is otherwise valid.
Recommended workflow for JSP file uploads
For reliable day-to-day deployment, it helps to follow a consistent workflow every time you upload JSP application files through Plesk or FTP.
Suggested workflow
- Confirm the correct deploy path in Plesk.
- Stop the app server if the change is major and the provider recommends it.
- Upload the new files or WAR package.
- Verify the folder structure and file names.
- Check permissions if needed.
- Restart or reload the app server service.
- Test the application in the browser.
- Review logs if anything fails.
This workflow reduces deployment mistakes and makes it easier to update JSP applications without affecting unrelated sites or services in the same hosting account.
FAQ
Can I upload JSP files directly to the website root?
Yes, if the hosting account is configured that way and the document root is mapped to your JSP application. In many Tomcat setups, however, the application should be uploaded to a specific deploy path rather than the top-level website folder.
Should I use FTP or Plesk File Manager?
Use Plesk File Manager for quick edits, small uploads, and checking folder structure. Use FTP or SFTP for larger applications, repeated deployments, or when you need to transfer many files efficiently.
Can I upload a WAR file instead of individual JSP files?
Yes, if your hosting plan and app server configuration support WAR deployment. This is often the easiest way to publish a complete JSP application.
Why does my JSP app work on my local machine but not after upload?
The most common reasons are incorrect deploy path, missing libraries, unsupported Java version, file permission issues, or an incomplete folder structure.
Do I need to restart Tomcat after uploading files?
Not always, but a restart or redeploy is often useful when you upload a WAR file, update configuration files, or change classes and libraries. Smaller JSP edits may appear after refresh, depending on caching and server settings.
What is the safest way to update one JSP page?
Upload only the changed JSP file to the correct folder, then verify the page in the browser. If your application uses cached compiled output, you may also need to restart the app server or clear temporary files according to your hosting provider's guidance.
Conclusion
Uploading JSP application files through Plesk or FTP is straightforward when you use the correct deploy path and preserve the expected Tomcat folder structure. In a Java hosting environment with My App Server, this process becomes even more practical because you can manage your own Tomcat instance, choose the Java version, and deploy JSP or WAR applications from the control panel.
For the best results, always verify the destination folder, keep WEB-INF and library files in the right place, check permissions, and confirm that the app server is running after upload. With these steps, you can deploy and update JSP applications reliably in a shared managed hosting account.