Where Junior Developers
Become Engineers

A hands-on backend engineering bootcamp.
Real projects. Real code reviews. Real growth.

Learn More
Poltergeist Labs ghost mascot
12 WeeksIntensive Program
Small CohortsFocused Mentorship
Real ProjectsProduction-Style
Career SupportFrom CV to Offers
Why Poltergeist Labs

What makes this different?

We focus on what really prepares you for a junior backend role.

Production-Style Projects

Build real backend systems from day one. No toy apps. Real architecture, real decisions, real engineering.

Mentorship That Matters

Learn in small groups with engineers who've been in your shoes. Direct feedback, not automated checks.

Code Reviews That Level Up

Get detailed feedback on your code, architecture decisions, and engineering mindset — not just syntax.

Career-Focused

We help you prepare for interviews, build your profile, and land your first engineering role.

The Program

12 Weeks. Built to take you from
strong fundamentals to real-world experience.

A structured path through backend engineering — from foundations to collaborative capstone.

01
Engineering FoundationsGit, GitHub, Architecture
›
02
REST & DatabaseSQL, REST APIs, JDBC
›
03
Spring CoreDI, Beans, Architecture
›
04
Spring Boot APIsControllers, DTOs, Validation
›
05
Auth & SecurityJWT, Spring Security
›
06
Testing & QualityUnit, Integration tests
›
07
Docker & EnvironmentContainers, Deployment
›
08
Redis & PerformanceCaching, Optimization
›
09–10
Team DevelopmentAgile, Capstone Sprints
›
11
Finalization & DeployDeploy, Docs, Bugfix
›
12
Demo Day & GraduationPresentations, Community
›
Java
1// Week 1 — Engineering Foundations
2public class UserService {
3
4 private final UserRepository repository;
5
6 public UserService(UserRepository repository) {
7 this.repository = repository;
8 }
9
10 public User findById(Long id) {
11 return repository.findById(id)
12 .orElseThrow(() -> new UserNotFoundException(id));
13 }
14}
Assignment

Set up project structure, Git workflow and first collaborative repository.

1@RestController
2@RequestMapping("/api/users")
3public class UserController {
4
5 @GetMapping("/{id}")
6 public ResponseEntity<User> getUser(@PathVariable Long id) {
7 User user = userService.findById(id);
8 return ResponseEntity.ok(user);
9 }
10
11 @PostMapping
12 public ResponseEntity<User> create(@RequestBody CreateUserRequest req) {
13 User created = userService.create(req);
14 return ResponseEntity.status(201).body(created);
15 }
16}
Assignment

Build a simple REST API connected to a SQL database.

1@Service
2public class OrderService {
3
4 private final OrderRepository orderRepository;
5 private final PaymentClient paymentClient;
6
7 public Order createOrder(CreateOrderRequest request) {
8 Order order = Order.create(request);
9 Payment payment = paymentClient.charge(request);
10 order.complete(payment);
11 return orderRepository.save(order);
12 }
13}
Assignment

Refactor previous API into proper Spring layered architecture.

1@RestController
2@RequestMapping("/api/orders")
3@Validated
4public class OrderController {
5
6 @PostMapping
7 public ResponseEntity<OrderDto> create(
8 @RequestBody @Valid CreateOrderRequest req) {
9 Order order = orderService.createOrder(req);
10 return ResponseEntity.status(201)
11 .body(OrderDto.from(order));
12 }
13
14 @ExceptionHandler(ValidationException.class)
15 public ResponseEntity<ErrorResponse> handleValidation(
16 ValidationException ex) {
17 return ResponseEntity.badRequest()
18 .body(new ErrorResponse(ex.getMessage()));
19 }
20}
Assignment

Build a production-style CRUD backend using Spring Boot.

1@Configuration
2@EnableWebSecurity
3public class SecurityConfig {
4
5 @Bean
6 public SecurityFilterChain filterChain(
7 HttpSecurity http) throws Exception {
8 return http
9 .authorizeHttpRequests(auth -> auth
10 .requestMatchers("/api/auth/**").permitAll()
11 .anyRequest().authenticated())
12 .addFilterBefore(jwtFilter,
13 UsernamePasswordAuthenticationFilter.class)
14 .build();
15 }
16}
Assignment

Implement authentication and authorization into existing backend project.

1@SpringBootTest
2class OrderServiceTest {
3
4 @MockBean
5 private OrderRepository repository;
6
7 @Autowired
8 private OrderService orderService;
9
10 @Test
11 void createOrder_shouldSaveAndReturn() {
12 given(repository.save(any())).willReturn(mockOrder());
13
14 Order result = orderService.createOrder(validRequest());
15
16 assertThat(result.getStatus())
17 .isEqualTo(OrderStatus.COMPLETED);
18 }
19}
Assignment

Add testing and logging into project workflow.

1@Configuration
2public class InfraConfig {
3
4 @Value("${app.redis.host}")
5 private String redisHost;
6
7 @Value("${app.db.url}")
8 private String dbUrl;
9
10 @Bean
11 public RedisConnectionFactory redisConnectionFactory() {
12 return new LettuceConnectionFactory(redisHost, 6379);
13 }
14
15 // docker run -p 6379:6379 redis:alpine
16 // docker run -p 5432:5432 postgres:15
17}
Assignment

Containerize backend application using Docker.

1@Service
2public class ProductService {
3
4 @Cacheable(value = "products", key = "#id")
5 public Product findById(Long id) {
6 return productRepo.findById(id)
7 .orElseThrow(ProductNotFoundException::new);
8 }
9
10 @CacheEvict(value = "products", key = "#id")
11 public void deleteById(Long id) {
12 productRepo.deleteById(id);
13 }
14
15 @CachePut(value = "products", key = "#result.id")
16 public Product update(UpdateProductRequest req) {
17 return productRepo.save(Product.from(req));
18 }
19}
Assignment

Integrate Redis caching into backend project.

1// Team PR — feature/payment-service
2@Service
3@Transactional
4public class PaymentService {
5
6 private final PaymentGateway gateway;
7 private final TransactionRepository txRepo;
8
9 public Transaction processPayment(PaymentRequest req) {
10 Payment result = gateway.charge(req);
11
12 if (!result.isSuccessful()) {
13 throw new PaymentFailedException(result.getReason());
14 }
15
16 return txRepo.save(Transaction.from(result));
17 }
18}
Assignment

Start and continue collaborative capstone backend project in teams with active PR reviews.

1@RestControllerAdvice
2public class GlobalExceptionHandler {
3
4 @ExceptionHandler(EntityNotFoundException.class)
5 public ResponseEntity<ErrorResponse> handleNotFound(
6 EntityNotFoundException ex) {
7 return ResponseEntity.status(404)
8 .body(new ErrorResponse("NOT_FOUND", ex.getMessage()));
9 }
10
11 @ExceptionHandler(Exception.class)
12 public ResponseEntity<ErrorResponse> handleGeneral(Exception ex) {
13 log.error("Unhandled exception", ex);
14 return ResponseEntity.status(500)
15 .body(new ErrorResponse("SERVER_ERROR", "Something went wrong"));
16 }
17}
Assignment

Prepare final backend system for presentation.

1// Capstone Project — Final Demo
2@SpringBootApplication
3public class PoltergeistApplication {
4
5 public static void main(String[] args) {
6 SpringApplication.run(
7 PoltergeistApplication.class, args);
8 }
9}
10
11// ────────────────────────────────────
12// Team: 4 developers
13// 847 commits · 112 pull requests
14// 68 code reviews · 3 deployments
15// ────────────────────────────────────
Final Outcome

Real backend project experience, collaborative development, production-style workflow, GitHub portfolio, and long-term community access.

Mentorship

You won't learn alone.

Every cohort is guided by experienced engineers who help students transition from isolated learning into real backend engineering workflow.

Weekly Live Sessions

  • Backend architecture
  • Spring Boot deep dives
  • Engineering practices
  • Debugging sessions
  • Real-world workflows

Code Reviews & Feedback

  • Code quality & readability
  • Architecture decisions
  • Problem solving
  • Engineering mindset

Pull Request Reviews

  • Collaborative Git workflow
  • Clean commits
  • Branch management
  • Real engineering communication

Daily Discord Support

  • Engineering discussions
  • Debugging help
  • Progress sharing
  • Announcements & community

Team Development Guidance

  • Architecture decisions
  • Project structure
  • Workflow organization
  • Collaboration practices

Career & Interview Support

  • Technical interview prep
  • CV & GitHub feedback
  • Backend engineering advice
  • Industry readiness guidance
Community

Beyond The Cohort

Graduation is not the end of the experience. Students remain part of the Poltergeist Labs community.

Poltergeist Labs ghost

Discord Access

Stay connected, continue engineering discussions, and get support long after graduation.

Networking Opportunities

Connect with fellow engineers, alumni, and mentors working in the industry.

Future Community Events

Participate in future cohort events, engineering sessions, and alumni activities.

Alumni Network

Be part of a growing network of engineers who went through the same journey.

FAQ

Frequently Asked Questions

Everything you need to know before applying.

Yes. This program is designed for developers who already understand Java fundamentals and basic OOP concepts. Poltergeist Labs is not a "learn programming from zero" course.
You should already be comfortable with:
  • Java basics
  • OOP principles
  • Basic Git usage
  • Writing simple applications independently
Yes — for junior developers. The program is built for people who already started learning backend development but feel stuck between tutorials and real engineering work.
Expect around 10–15 hours per week including:
  • Live sessions
  • Assignments
  • Self-study
  • Team collaboration
Each week includes live engineering sessions, practical backend assignments, mentor feedback, code reviews, and Discord collaboration.
Absolutely. Team collaboration is one of the core parts of the experience. The second half of the program focuses heavily on collaborative backend development and engineering workflow.
  • Java
  • Spring Boot
  • SQL
  • Git & GitHub
  • REST APIs
  • Docker
  • Redis
  • Backend architecture fundamentals
Yes. Students regularly work with pull requests, code reviews, Git workflows, and collaborative engineering practices throughout the program.
Yes. Cohorts are intentionally kept small to maintain strong mentorship quality and collaboration.
No. But the program is heavily focused on practical backend engineering skills, teamwork experience and interview readiness — designed to help students become stronger candidates in the job market.
Students remain part of the Poltergeist Labs community with continued access to Discord, networking, future events, engineering discussions, and alumni activities.
Because engineering is collaborative. We believe developers grow faster when they work together, review each other's code, solve problems as a team, and build inside a real engineering environment.

Join the Pilot Cohort

We're launching our first cohort soon.
Spots are limited. Apply to secure yours.

Poltergeist Labs ghost mascot