◈ DevSync

Developer Productivity Platform

Sync your team. Ship faster.

◈ Screenshots

◈ What is DevSync?

DevSync is a microservices-based developer productivity platform built for engineering teams. It solves a problem every software team faces — standups scattered across Slack threads, team leads with no visibility into blockers, and sprint retrospectives where nobody remembers what happened.

DevSync centralises daily standups, surfaces blocker trends, auto-generates sprint summaries, and visualises contribution heatmaps — all in one clean, fast web application.

The real problem it solves: A team lead managing 5 developers spends ~2 hours every Friday manually reading standup messages to write a sprint summary. Two developers have been blocked on the same issue for 3 days, but nobody connected the dots. DevSync automates the summary, surfaces the blockers, and gives the lead a heatmap of team consistency — in one dashboard.

◈ Architecture

Service Responsibilities

Service	Port	Database	Purpose
`auth-service`	`8081`	`auth_db:5432`	User registration, login, JWT token issuance, BCrypt password hashing
`standup-service`	`8082`	`standup_db:5433`	Daily standup CRUD, team feed, role-based access control
`analytics-service`	`8083`	`analytics_db:5434`	Heatmap, sprint summary, blocker reports via Strategy pattern
`notification-service`	`8084`	`notification_db:5435`	Scheduled email reminders (planned)

◈ Tech Stack

Backend

Technology	Version	Purpose
Spring Boot	3.2	Microservice framework
Spring Security	6.x	Auth filter chain, BCrypt
Spring Data JPA	3.2	ORM, repository layer
jjwt	0.11.5	JWT token generation & validation
PostgreSQL	17	Relational database
Lombok	Latest	Boilerplate elimination
Docker Compose	3.8	Local DB orchestration

Frontend

Technology	Version	Purpose
Next.js	14	React framework, App Router
TypeScript	5.0	Type safety
Tailwind CSS	3.x	Utility-first styling
Recharts	Latest	Heatmap & analytics charts
TanStack Query	5.x	Data fetching & caching
Framer Motion	Latest	Animations
Axios	Latest	HTTP client with interceptors
react-hot-toast	Latest	Toast notifications

◈ Key Features

🔐  JWT Authentication       Stateless auth with role-based access control
                             DEVELOPER · TEAM_LEAD · ADMIN

📝  Daily Standups           Structured format — what I did / doing / blockers
                             One post per day enforced at service level

👥  Team Feed                Team leads see entire team's standups
                             Missing members highlighted, date filtering

📊  Contribution Heatmap     GitHub-style grid showing posting consistency
                             Per-member consistency score calculated

📋  Sprint Summaries         Auto-generated weekly reports
                             Key activities + unresolved blockers

⚠️  Blocker Analytics        Frequency charts per team member
                             Most blocked member surfaced automatically

🔒  Role-Based Access        3-tier permission model
                             Enforced at controller layer via JWT claims

◈ OOP Design Patterns

DevSync is designed to demonstrate real-world object-oriented design:

Strategy Pattern — Report Generation

// Adding a new report type = one new class, zero changes to existing code
public interface ReportGenerator {
    Object generate(List<StandupResponse> standups, ReportRequest request);
    String getReportType();
}

@Component public class WeeklySummaryReport    implements ReportGenerator { }
@Component public class HeatmapReport          implements ReportGenerator { }
@Component public class BlockerFrequencyReport implements ReportGenerator { }

// Runtime lookup — O(1), Open/Closed Principle
generators.get("HEATMAP").generate(standups, request);

Inheritance — User Hierarchy

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public abstract class AppUser { }   // id, email, password, role

@Entity public class Developer extends AppUser { }  // techStack, githubHandle
@Entity public class TeamLead  extends AppUser { }  // teamName

Dependency Inversion — PasswordEncoder

// Service depends on abstraction, not BCrypt directly
private final PasswordEncoder passwordEncoder;  // → BCryptPasswordEncoder injected

◈ Getting Started

Prerequisites

Make sure you have these installed:

java -version    # JDK 21+
docker --version # Docker Desktop
node -v          # Node.js 20+
git --version    # Git

1. Clone the repository

git clone https://github.com/YOUR_USERNAME/devsync.git
cd devsync

2. Start all databases with Docker

docker compose up -d

# Verify all 4 containers are running
docker compose ps

This starts 4 PostgreSQL instances:

devsync-auth-db          → localhost:5432
devsync-standup-db       → localhost:5433
devsync-analytics-db     → localhost:5434
devsync-notification-db  → localhost:5435

3. Run each Spring Boot service

Open each service in IntelliJ and hit Run, or use terminal:

# Terminal 1
cd auth-service && mvn spring-boot:run

# Terminal 2
cd standup-service && mvn spring-boot:run

# Terminal 3
cd analytics-service && mvn spring-boot:run

Services start on ports 8081, 8082, 8083.

4. Verify services are up

curl http://localhost:8081/api/auth/health
curl http://localhost:8082/api/standup/health
curl http://localhost:8083/api/analytics/health

All should return { "status": "UP" }.

5. Run the frontend

cd frontend
npm install
npm run dev

Frontend starts at http://localhost:5173

◈ Environment Variables

Each Spring Boot service uses application.properties. For the frontend, create frontend/.env.local:

NEXT_PUBLIC_AUTH_URL=http://localhost:8081
NEXT_PUBLIC_STANDUP_URL=http://localhost:8082
NEXT_PUBLIC_ANALYTICS_URL=http://localhost:8083

⚠️ Never commit production secrets. The dev123 password in docker-compose.yml is for local development only. Use environment variables for production credentials on Railway/Neon.

◈ API Reference

Auth Service `localhost:8081`

POST   /api/auth/register    Register a new user
POST   /api/auth/login       Login and receive JWT token
GET    /api/auth/health      Health check

Standup Service `localhost:8082`

All endpoints require Authorization: Bearer {token}

POST   /api/standup                           Post today's standup
GET    /api/standup/my                        Get my standup history
GET    /api/standup/today                     Get today's standup
GET    /api/standup/team/{name}?date=         Team feed (TEAM_LEAD+)
GET    /api/standup/team/{name}/blockers      Team blockers (TEAM_LEAD+)
GET    /api/standup/team/{name}/range?from=&to= Date range (TEAM_LEAD+)
GET    /api/standup/health                    Health check

Analytics Service `localhost:8083`

Requires Authorization: Bearer {token} — TEAM_LEAD + ADMIN only

POST   /api/analytics/report/WEEKLY_SUMMARY    Sprint summary report
POST   /api/analytics/report/HEATMAP           Contribution heatmap
POST   /api/analytics/report/BLOCKER_FREQUENCY Blocker frequency report
POST   /api/analytics/blockers                 Blocker shortcut endpoint
GET    /api/analytics/health                   Health check

◈ Project Structure

devsync/
│
├── auth-service/                   # JWT auth, user management
│   └── src/main/java/com/devsync/auth/
│       ├── model/                  # AppUser entity, Role enum
│       ├── dto/                    # RegisterRequest, LoginRequest, AuthResponse
│       ├── repository/             # UserRepository
│       ├── service/                # UserService (BCrypt, JWT)
│       ├── controller/             # AuthController
│       ├── config/                 # SecurityConfig, WebConfig, GlobalExceptionHandler
│       └── util/                   # JwtUtil
│
├── standup-service/                # Core domain — standup CRUD
│   └── src/main/java/com/devsync/standup/
│       ├── model/                  # Standup entity, StandupStatus enum
│       ├── dto/                    # CreateStandupRequest, StandupResponse, TeamStandupResponse
│       ├── repository/             # StandupRepository (custom JPA queries)
│       ├── service/                # StandupService
│       ├── controller/             # StandupController
│       └── config/                 # JwtFilter, WebConfig, GlobalExceptionHandler
│
├── analytics-service/              # Report generation, Strategy pattern
│   └── src/main/java/com/devsync/analytics/
│       ├── dto/                    # HeatmapResponse, SprintSummary, BlockerReport
│       ├── report/                 # ReportGenerator interface + 3 implementations
│       ├── service/                # AnalyticsService (strategy map)
│       ├── client/                 # StandupClient (inter-service HTTP)
│       ├── controller/             # AnalyticsController
│       └── config/                 # JwtFilter, WebConfig, AppConfig
│
├── frontend/                       # Next.js 14 + Tailwind
│   └── src/
│       ├── app/                    # App Router pages
│       ├── components/             # UI, layout, standup, analytics components
│       ├── context/                # AuthContext
│       ├── hooks/                  # useAuth, useStandups
│       ├── lib/                    # Axios instances
│       └── types/                  # TypeScript interfaces
│
└── docker-compose.yml              # 4 PostgreSQL databases

◈ Deployment

Service	Platform	Notes
Spring Boot services	Railway	Auto-detects Maven, 4 separate services
React frontend	Vercel	Connect GitHub repo, instant deploy
Production database	Neon DB	Serverless Postgres, free tier

Steps

Create 4 databases on Neon (one per service)
Deploy each Spring Boot service to Railway
Set environment variables (DB URL, JWT secret) in Railway dashboard
Deploy frontend to Vercel, set NEXT_PUBLIC_* env vars
Set up UptimeRobot to ping /health every 5 min — keeps JVM warm

◈ Roadmap

◈ System Design Highlights

Stateless Authentication JWT tokens are self-contained — any service instance can validate any token without hitting a database or shared session store. Enables horizontal scaling with zero coordination overhead.

Database Per Service Each microservice owns its schema. Analytics queries never contend with standup writes. Services are independently deployable and independently scalable.

Fault Isolation If analytics-service goes down, standup posting and auth still work perfectly. StandupClient returns empty list on failure — no cascade.

Open/Closed Principle Adding a new analytics report type requires adding one new @Component class that implements ReportGenerator. Zero changes to AnalyticsService or the controller. Discovered via Spring's dependency injection at startup.

◈ Interview Pitch

"I built DevSync — a microservices-based developer productivity platform using 4 Spring Boot services, React with Next.js, PostgreSQL on Neon, and Docker Compose for orchestration. It features stateless JWT authentication with role-based access control across three user types, a GitHub-style contribution heatmap, and auto-generated sprint summaries. I applied the Strategy design pattern for pluggable report generation — adding a new report type requires one new class and zero changes to existing code, directly implementing the Open/Closed Principle."

◈ Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

# Fork the repo
# Create your feature branch
git checkout -b feature/your-feature-name

# Commit with conventional commits
git commit -m "feat: add Redis caching to analytics service"

# Push and open a PR
git push origin feature/your-feature-name

◈ License

Distributed under the MIT License. See LICENSE for more information.

Built with patience, Spring Boot, and too much coffee ☕

⬆ back to top

Name		Name	Last commit message	Last commit date
.idea		.idea
analytics-service/analytics-service		analytics-service/analytics-service
auth-service/auth-service		auth-service/auth-service
devsync-frontend		devsync-frontend
notification-service/notification-service		notification-service/notification-service
standup-service/standup-service		standup-service/standup-service
README.md		README.md
devsync_test_report.md		devsync_test_report.md
docker-compose.yml		docker-compose.yml
get_responses.ps1		get_responses.ps1
test_apis.ps1		test_apis.ps1

Latest commit

History

Folders and files

Repository files navigation