Full-Stack Development · Enterprise Platform
Piko Admin Dashboard
& Analytics Platform
Enterprise management system for a social platform serving 1,000+ daily active users — built from scratch, owned end to end.
Early development prototype — production system is not publicly accessible
Project Overview
Built from scratch as the central command center for managing PetoKingdom (Piko) — a social platform serving 1,000+ daily active users. Provides comprehensive tooling for user governance, real-time analytics, content moderation, and platform configuration, enabling data-driven decision-making under enterprise security standards.
Business Impact
Increased platform insights by 300% by transforming 15+ disparate data sources into unified, actionable visualizations. Reduced administrative processing time by 60% through automated workflows with JWT authentication and role-based access control. Coordinated requirements across 5+ departments while mentoring 3 interns, cutting onboarding time by 40%.
The Challenge
As PetoKingdom prepared for launch, the team needed comprehensive administrative tools to manage users, monitor platform health, and support data-driven decisions — all with enterprise-grade security protecting sensitive user data across a microservices architecture.
Data fragmentation
15+ activity sources scattered across microservices with no unified view for decision-making.
Enterprise security
Authentication, multi-role authorization, and audit logging required from day one — not bolted on later.
Real-time processing
Live dashboards requiring complex SQL with CTEs, window functions, and time-series analytics.
Cross-team coordination
Requirements from 5+ departments (Marketing, Support, Product, Engineering, Operations) with diverse technical backgrounds.
System Architecture
Layer 1 — Frontend
React 19 + TypeScript + Material-UI
50+ reusable components, responsive dashboard, Redux state management
Layer 2 — API Gateway
RESTful APIs + JWT Authentication
Secure request routing, token validation, CORS configuration
Layer 3 — Backend Services
Java Spring Boot 3 Microservices
Analytics, User Management, Moderation, Bulk Email (AWS SES)
Layer 4 — Data Layer
PostgreSQL (15+ tables)
Complex CTEs, window functions, indexes, Flyway migrations
Layer 5 — Infrastructure
Docker + AWS + GitHub Actions
Containerized deployment, cloud hosting, CI/CD pipeline
// Request lifecycle
Frontend (React/TypeScript)
→ REST API (Spring Boot)
→ Service Layer (Business Logic + Audit Logging)
→ Repository Layer (JPA / Hibernate)
→ PostgreSQL (CTEs · Window Functions · Indexes)
→ AWS (SES · S3)
Key Technical Contributions
Comprehensive Analytics Platform
Unified 15+ data sources into real-time actionable dashboards
Challenge: Activity data was scattered across multiple microservices with no unified view — stakeholders were flying blind on platform health and user growth.
Solution: Designed and built a full analytics pipeline processing data from all microservices, surfacing it through Plotly.js and Chart.js dashboards.
Analytics modulesUser Analytics
- Active user tracking (DAU/MAU)
- Registration trends + time-series charts
- User growth vs. churn analysis
- Demographics and segmentation
Platform Growth
- Monthly/weekly activity growth
- Platform overview metrics
- Species distribution analysis
- Peak activity hours/days
Content Analytics
- Post creation metrics
- Engagement by action type
- Content quality indicators
- Zero-engagement post tracking
Activity Insights
- Daily/weekly activity distribution
- Peak posting hours
- Average posts per pet
- Comprehensive activity summaries
// Monthly growth with MoM comparison
@Query("""
WITH monthly_stats AS (
SELECT
DATE_FORMAT(created_at, '%Y-%m') AS month,
COUNT(DISTINCT user_id) AS active_users,
COUNT(*) AS total_posts,
LAG(COUNT(DISTINCT user_id))
OVER (ORDER BY DATE_FORMAT(created_at, '%Y-%m')) AS prev_month_users
FROM activities
WHERE created_at >= :startDate
GROUP BY month
)
SELECT
month, active_users, total_posts,
ROUND(((active_users - prev_month_users) / prev_month_users) * 100, 2) AS growth_rate
FROM monthly_stats
ORDER BY month DESC
""")
List<MonthlyActivityGrowthDto> getMonthlyGrowth(
@Param("startDate") LocalDateTime startDate);Enterprise-Grade Authentication & RBAC
JWT auth, multi-role authorization, audit logging — built foundational
Challenge: Admin operations require granular permission control, full audit trails, and hardened security — it couldn't be patched on after the fact.
Solution: Built complete security infrastructure using Spring Security with JWT, implementing 4+ role hierarchy and comprehensive audit logging from day one.
JWT Authentication
- Stateless token-based auth
- Access + refresh token rotation
- BCrypt password hashing
- Token expiration management
Role-Based Access Control
- 4-tier hierarchy (Super Admin → Viewer)
- Granular permission system
- Route-level authorization
- Resource-based access control
Security Hardening
- Account lockout after failed attempts
- Password complexity enforcement
- HTTPS enforcement + CORS
- Stateless session management
Audit & Compliance
- Comprehensive audit logging
- Admin action tracking
- Security event monitoring
- Compliance reporting
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.csrf(AbstractHttpConfigurer::disable)
.sessionManagement(s ->
s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
.authorizeHttpRequests(auth -> auth
.requestMatchers("/api/auth/**").permitAll()
.requestMatchers("/api/admin/**").hasAnyRole("ADMIN", "SUPER_ADMIN")
.requestMatchers("/api/users/**").hasRole("SUPER_ADMIN")
.anyRequest().authenticated()
)
.addFilterBefore(jwtAuthenticationFilter,
UsernamePasswordAuthenticationFilter.class);
return http.build();
}
}Complete User Management System
Full CRUD, advanced filtering, bulk operations — 1,000+ users managed
Challenge: Managing 1,000+ users manually was unsustainable. The team needed role management, bulk operations, and advanced search without writing custom queries.
Solution: Built a full user management system with server-side pagination, Specification-based filtering, and role assignment with audit trails.
Core operations
- Create, Read, Update, Delete users
- Role assignment and permission management
- Account status control (active / suspended / banned)
- Password reset and forced change
- Bulk operations for efficiency
Advanced features
- Advanced filtering (role, status, date range)
- Server-side pagination via DataGrid
- Full-text search across multiple fields
- Export to CSV / Excel
- User statistics and activity tracking
@Service
public class UserService {
public Page<UserResponse> getUsers(
String search, Role role, UserStatus status, Pageable pageable) {
Specification<User> spec = Specification
.where(UserSpecification.hasSearchTerm(search))
.and(UserSpecification.hasRole(role))
.and(UserSpecification.hasStatus(status));
return userRepository.findAll(spec, pageable)
.map(this::mapToUserResponse);
}
@Transactional
public UserResponse updateUserRole(Long userId, Role newRole) {
User user = findUserById(userId);
auditService.log(AuditAction.UPDATE_USER_ROLE, userId,
getCurrentAdmin(),
Map.of("oldRole", user.getRole(), "newRole", newRole));
user.setRole(newRole);
return mapToUserResponse(userRepository.save(user));
}
}Automated Content Moderation System
Multi-type report handling with bulk actions — 50% faster review cycles
Built a comprehensive report management system with a multi-tab interface covering Posts, Messages, Users, Events, Technical, and Other categories. Advanced filtering by time period, report type, and status — combined with quick bulk actions (ban, delete, dismiss) and full audit trails.
Report management
- Multi-tab interface by report type
- Time-based filtering + priority sorting
- Server-side pagination at scale
Quick actions
- Ban user, delete content, dismiss report
- Confirmation dialogs + audit trails
- Bulk operations for efficiency
Analytics integration
- Moderation trend dashboards
- Response time metrics
- Content quality indicators
Advanced filtering
- Filter by entity type, status, time range
- Cross-type report search
- Export moderation reports
Bulk Email Management via AWS SES
Non-technical teams send targeted campaigns without writing a single query
Integrated AWS Simple Email Service with a user-friendly interface for bulk email campaigns — including user segmentation, HTML template support, real-time delivery tracking, and bounce handling.
Target by user type, role, or custom recipient list with real-time recipient count preview.
HTML email templates with variable substitution for personalization across campaigns.
Real-time job progress monitoring with per-recipient success/failure status.
Reliable delivery with bounce and complaint handling, rate limiting, and delivery analytics.
Full-Stack Architecture & Infrastructure
Database schema to frontend deployment — complete ownership
Frontend architecture
- 50+ reusable React/TypeScript components
- Material-UI design system
- Redux state management
- Chart.js + Plotly.js data visualization
- Responsive grid layouts
Backend services
- Spring Boot microservices
- RESTful APIs with OpenAPI docs
- JPA/Hibernate ORM
- Service + DTO pattern
- Global exception handling
Database design
- 15+ normalized PostgreSQL tables
- Indexes for query optimization
- CTEs and window functions
- Time-series data handling
- Flyway migration scripts
DevOps & infrastructure
- Docker containerization
- AWS cloud deployment
- CI/CD via GitHub Actions
- Health checks and monitoring
- Structured logging + error tracking
Complete Technology Stack
Frontend
Backend
Database & Data
Cloud & Infrastructure
Development Tools
Quantitative Results
15+ data sources unified into real-time dashboards with Plotly.js and Chart.js visualizations.
Automated administrative workflows with JWT auth and role-based permissions.
Platform scaled to 1,000+ daily active users with comprehensive admin controls.
50+ reusable components reduced time-to-market for every subsequent feature.
20+ comprehensive guides and mentorship of 3 interns reduced ramp-up from weeks to days.
JWT auth, 4-tier RBAC, audit logging, and security hardening built foundational — zero post-launch incidents.
Cross-Functional Leadership
Requirements gathering
Coordinated with 5+ departments (Marketing, Support, Product, Engineering, Operations) to gather requirements and translate business needs into technical specifications.
Agile facilitation
Led sprint planning, daily standups, and retrospectives. Maintained backlog and tracked velocity to improve delivery consistency.
Stakeholder communication
Ran regular demos presenting analytics insights and new features, gathering iterative feedback from non-technical stakeholders.
Technical liaison
Bridged technical and non-technical teams — explaining constraints in business terms, translating requirements into specs.
Mentorship & training
Mentored 3 interns on full-stack development, ran knowledge-share sessions, and authored 20+ technical SOPs, API specs, and troubleshooting guides.
Production support
Owned application support for 1,000+ daily operations — incident response, monitoring, and reliability for a live production platform.
Engineering Learnings
Architecture decisions compound
Early choices in schema design, API contracts, and component structure either accelerate or constrain everything downstream. Upfront thinking pays off multiplicatively.
Security can't be bolted on
JWT + RBAC + audit logging had to be foundational. Trying to retrofit enterprise security would have required a near-complete rewrite of the backend.
Complex SQL is a superpower
Mastering CTEs and window functions unlocked analytics that would otherwise require separate ETL pipelines — and eliminated N+1 query problems across the board.
Component libraries accelerate velocity
Building 50+ reusable components before full requirements were finalized paid dividends immediately — every new feature was 40% cheaper to ship.
Documentation is product development
20+ guides reduced onboarding from weeks to days. Good documentation scales knowledge and reduces the support burden — it's essential infrastructure, not "extra" work.
Technical skills alone aren't sufficient
The highest-leverage moments were understanding a department's underlying goal, translating it accurately, and scoping it realistically — not the coding itself.
Development Roadmap
Phase 1 — Foundation
- React + Spring Boot architecture
- JWT authentication & 4-tier RBAC
- User management with CRUD + bulk ops
- Analytics platform — 15+ data sources
- Content moderation system
- Docker deployment to AWS
Phase 2 — Advanced Features
- Feature toggle system for A/B testing
- ML-powered analytics insights
- Real-time notifications (WebSocket)
- Automated PDF/Excel report generation
- Enhanced audit logging dashboard
- Mobile-responsive UI improvements
Phase 3 — Enterprise Scale
- Multi-tenant support for white-labeling
- Custom role hierarchy builder
- GraphQL API for flexible queries
- Kubernetes orchestration
- ElasticSearch log analytics
- Test coverage >80%