Enterprise Java + Spring Boot + Angular Development Setup Guide

An End-to-End Beginner’s Guide to Setting Up a New Development Laptop and Running Your First Project

Whether you’ve just joined a new company, received a brand-new laptop, or are learning enterprise Java development for the first time, the initial setup can feel overwhelming.

Enterprise applications often consist of multiple repositories, numerous software dependencies, environment variables, databases, IDE configurations, Maven builds, Node.js packages, and application properties. Missing even one step can prevent the application from starting.

This guide walks through the complete setup process — from an empty laptop to successfully running both the backend (Java/Spring Boot) and frontend (Angular).

Table of Contents

1. Understanding the Tech Stack
2. Software Installation Order
3. Install Git
4. Install Java (JDK)
5. Configure JAVA_HOME
6. Install IntelliJ IDEA
7. Install Maven
8. Configure Maven
9. Install Node.js
10. Install Visual Studio Code (Optional)
11. Install Database Client (If Needed)
12. Clone Git Repositories
13. Import Spring Boot Project
14. Configure Maven Dependencies
15. Configure application.properties/application.yml
16. Run Backend
17. Setup Angular Project
18. Install Node Packages
19. Run Angular UI
20. Common Issues and Fixes
21. Useful Commands
22. Best Practices

1. Understanding the Technology Stack

A typical enterprise project consists of two separate repositories.

Backend Repository

Typically contains:

• Java
• Spring Boot
• Maven
• REST APIs
• Database connectivity
• Business logic

Example folder

backend-service/

    src/
    pom.xml
    mvnw
    application.yml

Frontend Repository

Typically contains

• Angular
• Node.js
• npm
• TypeScript
• HTML
• CSS

Example

ui-project/

    src/
    package.json
    angular.json

Software Installation Sequence

Always install software in this order.

1. Git
2. Java JDK
3. Configure JAVA_HOME
4. IntelliJ IDEA
5. Maven
6. Node.js
7. VS Code (optional)
8. Database Client (optional)
9. Clone repositories
10. Open backend
11. Build backend
12. Open frontend
13. Install npm packages
14. Run applications

Following this sequence avoids dependency issues.

Step 1 — Install Git

Git is required to download source code repositories.

Download from: https://git-scm.com/downloads, according to your system configuration (Windows/Mac/Linux).

Install using all default options.

Verify installation

Windows

git --version

Sample output

git version 2.47.0

Configure Git

git config --global user.name "John Smith"

git config --global user.email "john@email.com"

Verify

git config --list

Step 2 — Install Java JDK

Spring Boot applications require the Java Development Kit.

Most enterprise applications currently use

• Java 17
• Java 21

Never install a random version.

Always verify the project documentation or ask your team.

Download from Oracle: https://www.oracle.com/java/technologies/downloads/

Or OpenJDK: https://openjdk.org/install/

Step 3 — Configure JAVA_HOME

Search — Environment Variables — Open System Properties — Environment Variables — Add

JAVA_HOME = C:\Program Files\Java\jdk-17 (Location to your JAVA)

Update path — Add — %JAVA_HOME%\bin

Restart Command Prompt

Verify

echo %JAVA_HOME%

Verify installation

java -version

Sample output

java version "17.0.12" 2024-07-16 LTS
Java(TM) SE Runtime Environment (build 17.0.12+8-LTS-286)
Java HotSpot(TM) 64-Bit Server VM (build 17.0.12+8-LTS-286, mixed mode, sharing)

Verify compiler

javac -version
Sample output - javac 17.0.12

Step 4 — Install IntelliJ IDEA

Download Community or Ultimate Edition — https://www.jetbrains.com/idea/download/

Ultimate edition is commonly used in enterprise projects because it includes:

• Spring Boot support
• Database tools
• Advanced debugging
• Docker integration

Community edition works for learning.

Recommended Plugins to install in IntelliJ:

• Lombok
• Maven
• Spring Boot
• Git
• SonarLint

If you need any help with plugin installation, refer this guide — https://medium.com/@smita.s.kothari/how-to-install-a-plugin-in-intellij-idea-820e59bf65bc

Step 5 — Install Maven

Some projects use the Maven Wrapper (mvnw), which means a separate Maven installation is optional. If your project does not include mvnw, install Maven.

Download and extract— https://maven.apache.org/download.cgi

Example

C:\Tools\apache-maven-3.9.10

Set

MAVEN_HOME

Update PATH

%MAVEN_HOME%\bin

Verify

mvn --version

In case if the maven is not working as expected, you can use this guide for debugging — https://medium.com/@smita.s.kothari/debugging-maven-installation-on-windows-when-mvn-is-not-recognized-even-though-maven-is-installed-1995a3d8054b?postPublishedType=initial

Step 6 — Install Node.js

Angular requires Node.js.

Download — https://nodejs.org/

Always install the LTS version.

Verify

node -v

Sample output (depending on the version you have installed)

v22.x.x

Verify npm

npm -v

Step 7 — Install Visual Studio Code (Optional)

Useful for editing Angular projects or configuration files.

Download — https://code.visualstudio.com/

Get Smita Kothari’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Recommended extensions

• Angular Language Service
• Prettier
• ESLint
• GitLens
• REST Client

Step 8 — Install Database Client (Optional)

Depending on your project, install a client such as:

• DBeaver
• MySQL Workbench
• pgAdmin
• SQL Server Management Studio

Your team should provide the connection details.

Step 9 — Clone the Repositories

Navigate to your workspace.

• Example: C:\Projects
• Clone backend: git clone https://github.com/company/backend.git
• Clone frontend: git clone https://github.com/company/frontend.git
• Navigate: cd backend

Step 10 — Open Backend in IntelliJ

• Select — Open
• Choose backend folder.
• IntelliJ automatically detects pom.xml
• Select — Import Maven Project
• Wait several minutes while Maven downloads dependencies.

Step 11 — Download Maven Dependencies

From terminal

mvn clean install

or

mvn clean package

If using Maven Wrapper

Windows

mvnw clean install

Linux

./mvnw clean install

This downloads all project libraries.

Step 12 — Configure application.properties

• Locate — src/main/resources
• Open — application.properties or application.yml
• Typical configuration

server.port=8080

spring.datasource.url=jdbc:mysql://localhost:3306/companydb

spring.datasource.username=root

spring.datasource.password=password

spring.jpa.hibernate.ddl-auto=update

Some companies store sensitive values in:

• Environment variables
• Vault
• AWS Secrets Manager
• Azure Key Vault

Never commit passwords into Git.

Step 13 — Build the Project

• Inside IntelliJ — Build — Build Project
• or terminal — mvn clean install

Common first-time errors

Missing Java

JAVA_HOME not found

Missing Maven

mvn is not recognized

Wrong Java version

Unsupported class version

Step 14 — Run Spring Boot

• Locate — Application.java
• Contains — @SpringBootApplication
• Click — Run
• or terminal — mvn spring-boot:run
• Successful startup — Tomcat started on port 8080
• Open — http://localhost:8080 or http://localhost:8080/swagger-ui.html or http://localhost:8080/swagger-ui/index.html depending on your project.

Step 15 — Open Angular Repository

• Navigate — cd frontend
• Install packages — npm install
• This reads — package.json and downloads all dependencies.

Step 16 — Verify Angular CLI

• Check — ng version
• If unavailable, Install globally — npm install -g @angular/cli
• Verify — ng version

Step 17 — Run Angular

ng serve

or

npm start

Successful output

Compiled successfully

Open

http://localhost:4200

Backend and Frontend Together

Run backend first

localhost:8080

Run frontend

localhost:4200

Angular communicates with Spring Boot APIs.

Typical flow

Browser -> Angular -> HTTP REST API -> Spring Boot -> Database

Useful Git Commands

Clone repository

git clone <repository-url>

Check status

git status

Pull latest changes

git pull

Create new branch

git checkout -b feature/new-feature

Switch branch

git checkout develop

Commit

git add .

git commit -m "Added feature"

Push

git push

Useful Maven Commands

Clean

mvn clean

Compile

mvn compile

Run tests

mvn test

Package

mvn package

Install

mvn install

Run Spring Boot

mvn spring-boot:run

Useful npm Commands

Install packages

npm install

Start Angular

npm start

or

ng serve

Build

ng build

Run tests

ng test

Update packages

npm update

Common Issues

Enterprise Development Best Practices

• Read the project’s README.md before starting.
• Confirm the required Java, Node.js, and Maven versions with your team.
• Use the project’s Maven Wrapper (mvnw) when available to avoid version mismatches.
• Keep your local branch updated with the main development branch.
• Never commit passwords, API keys, or certificates to source control.
• Commit frequently with meaningful commit messages.
• Resolve build warnings early instead of allowing them to accumulate.
• Learn to read stack traces — often the first error is the most useful.
• Ask for sample configuration files (such as application-example.yml or .env.example) if they are not included in the repository.
• Document any setup steps unique to your project for future team members.

Final Thoughts

The first setup of an enterprise Java project can seem intimidating because it involves many moving parts: development tools, build systems, source control, databases, backend services, and frontend frameworks. However, once your environment is configured correctly, day-to-day development becomes much smoother.

A reliable workflow is to install prerequisites in the correct order, verify each installation before moving to the next step, clone the repositories, import the backend into IntelliJ, resolve Maven dependencies, configure the application, and then set up the Angular frontend. Taking the time to understand each tool — Git for version control, Java and Spring Boot for backend development, Maven for dependency management, Node.js and Angular for the user interface, and IntelliJ for development — will make troubleshooting easier and help you become productive more quickly.

Remember that every organization has its own conventions, but the core setup process remains largely the same. Build a habit of consulting the project’s documentation, asking questions when requirements are unclear, and keeping notes on any environment-specific configurations. Those habits will serve you well throughout your career in enterprise software development.