import java.math.BigDecimal;
import java.math.RoundingMode;

public class DataRating {
    // Price per MB in rupees, with a free allowance per day
    private static final BigDecimal PRICE_PER_MB = new BigDecimal("0.25");
    private static final long FREE_MB = 1024;

    public static BigDecimal charge(long usedMb) {
        long chargeable = Math.max(0, usedMb - FREE_MB);
        return PRICE_PER_MB.multiply(BigDecimal.valueOf(chargeable))
                           .setScale(2, RoundingMode.HALF_UP);
    }

    public static void main(String[] args) {
        System.out.println(charge(900));    // 0.00
        System.out.println(charge(1500));   // 119.00
    }
}

public enum OrderState { RECEIVED, VALIDATED, PROVISIONING, ACTIVE, FAILED }

public record PlanOrder(String orderId, String msisdn, String planCode, OrderState state) {
    public PlanOrder next(OrderState newState) {
        if (state == OrderState.ACTIVE || state == OrderState.FAILED) {
            throw new IllegalStateException("Order already finished: " + orderId);
        }
        return new PlanOrder(orderId, msisdn, planCode, newState);
    }
}

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.Map;
import java.util.UUID;

@RestController
@RequestMapping("/api/orders")
public class PlanOrderController {

    record PlanChangeRequest(String msisdn, String planCode) {}

    @PostMapping
    public ResponseEntity<?> create(@RequestBody PlanChangeRequest req) {
        if (req.msisdn() == null || !req.msisdn().matches("\\d{10}")) {
            return ResponseEntity.badRequest().body(Map.of("error", "msisdn must be 10 digits"));
        }
        String orderId = UUID.randomUUID().toString();
        // save order as RECEIVED and publish an event for provisioning
        return ResponseEntity.accepted().body(Map.of("orderId", orderId, "state", "RECEIVED"));
    }
}

Terms worth knowing for interviews
MSISDN   — the mobile number of a subscriber
CDR      — call/usage detail record, input to billing
BSS/OSS  — business and operations support systems
Provisioning — activating a service on the network
Rating   — pricing usage according to plan rules
Churn    — customers leaving for another provider

-- PostgreSQL: ignore a usage record that was already loaded
CREATE TABLE usage_records (
  cdr_id     VARCHAR(64) PRIMARY KEY,
  msisdn     VARCHAR(15) NOT NULL,
  used_mb    BIGINT      NOT NULL,
  event_time TIMESTAMP   NOT NULL
);

INSERT INTO usage_records (cdr_id, msisdn, used_mb, event_time)
VALUES ('CDR-0001', '9876543210', 350, '2026-11-01 10:15:00')
ON CONFLICT (cdr_id) DO NOTHING;

import java.util.function.Supplier;

public final class Retry {
    public static <T> T withBackoff(Supplier<T> call, int maxAttempts) throws InterruptedException {
        long waitMs = 200;
        for (int attempt = 1; ; attempt++) {
            try {
                return call.get();
            } catch (RuntimeException e) {
                if (attempt >= maxAttempts) throw e;   // give up; caller sends to dead-letter queue
                Thread.sleep(waitMs);
                waitMs *= 2;                           // 200, 400, 800 ms ...
            }
        }
    }
}

Mini telecom BSS project (fake data)
☐ Spring Boot API to create plan-change orders (202 Accepted)
☐ Order state machine with audit table
☐ Kafka event to a provisioning consumer
☐ Idempotent CDR loader with unique cdr_id
☐ Rating service using BigDecimal
☐ README: architecture diagram, failure handling

Weeks 1-2: Core Java, OOP, collections, exceptions
Weeks 3-4: SQL, transactions, Spring Boot REST
Week 5:    Testing with JUnit and Mockito
Week 6:    Kafka producer/consumer, retries
Weeks 7-8: Domain project, telecom vocabulary, mock interviews

☐ Explain BSS vs OSS in two sentences
☐ Why BigDecimal for billing
☐ How my consumer handles duplicates
☐ What 202 Accepted means and when to use it
☐ One production-style bug I would watch for