The project explicitly covers user, catalog, and transaction flows under one layered REST API baseline.
GoCommerce API
Built during a project-based internship, this API turned core commerce workflows into cleaner service boundaries for auth, catalog, and transaction logic.
A source-backed case study built for recruiter review
This reading path makes the problem choice, evidence quality, user framing, execution decisions, and proof trail visible without overstating what the sources support.
A layered Golang REST API for core e-commerce operations built during project-based internship delivery.
Delivered a maintainable API surface and reduced integration friction through standardized responses.
Controller-usecase-repository pattern with JWT auth middleware and relational data model in MySQL.
Problem framing before execution
The case-study layer starts with why this problem was selected and how the context justified investment.
Problem Framing Map
An e-commerce backend becomes fragile when auth, catalog, and transaction workflows are not organized into maintainable service boundaries.
This API was built during a project-based internship, so the strongest recruiter value comes from how core commerce workflows were translated into a scalable backend baseline.
It is one of the highest-value remaining projects because it adds real internship delivery context while still having a clear architecture and workflow story.
Problem statement
The internship brief required a scalable backend foundation for user, catalog, and transaction flows.
Solution thesis
Implemented a layered architecture with authentication, catalog management, and transaction workflows.
What supports the narrative
Evidence is surfaced with its source type and credibility note so the recruiter can quickly see what is directly backed versus intentionally constrained.
The implementation uses controller-usecase-repository separation with JWT auth and MySQL-backed relations.
Credibility Notes
- ●The case is framed as internship-backed backend delivery and architecture evidence, not as a public production-scale commerce platform.
- ●No throughput, conversion, or business-operations claim is added beyond the source-backed implementation story.
User framing stays explicit
When formal research artefacts are not available, the page still explains who the work served and why that user framing is justified by the existing sources.
The strongest project proof is the layered backend organization that reduces endpoint fragility as scope grows.
Standardized responses and JWT-protected routes are core parts of the project value proposition.
How design thinking translated into decisions
The goal is to show the trace from research and insight to concrete product or system decisions, then to the outcomes those decisions supported.
Design Thinking Flow
Each step keeps the movement from evidence to action explicit before the rationale expands it.
- Step 1Commerce baseline framing
Started from the need for a scalable backend foundation before expanding feature breadth.
Signal: Auth, catalog, and transaction flows became the structural core. - Step 2Layered service design
Separated HTTP handling from business logic so the system would stay easier to maintain.
Signal: Controller-usecase-repository structure became the main quality signal. - Step 3Security-aware delivery
Added JWT-based protection as part of the base architecture instead of a later patch.
Signal: Protected route handling was built into the service baseline.
Decision Rationale
Each decision keeps the path from insight to execution visible before ending on the outcome signal.
Commerce APIs become harder to extend when handlers, business logic, and data access are tightly mixed.
Used a controller-usecase-repository pattern to separate concerns.
The API reads as maintainable and internship-relevant beyond CRUD delivery alone.
Transaction-oriented flows need explicit access control to remain safe and extensible.
Integrated JWT auth middleware into the protected endpoint baseline.
Security stays visible as part of the architecture instead of an afterthought.
Execution choices and delivery details
This section preserves the technical and operational substance: architecture, responsibilities, trade-offs, and implementation quality signals.
System Design
Controller-usecase-repository pattern with JWT auth middleware and relational data model in MySQL.
Source-backed Impact
Delivered a maintainable API surface and reduced integration friction through standardized responses.
Responsibilities
- ●Owned API module design and data relations
- ●Built auth and middleware flows
- ●Implemented CRUD and transaction endpoints
Stack Decisions
- ●Used Gin for lightweight request handling
- ●Used GORM for rapid relational query development
Trade-offs
- ●ORM abstraction speed vs lower SQL-level control
- ●Optimized for maintainability over low-level custom tuning
Challenges
- ●Ensuring clean endpoint contracts while maintaining delivery speed
Architecture and outcome snapshot
This visual layer keeps execution readable: how the system or delivery flow was structured and which source-backed outcomes mattered most.
Execution Flow
- Step 1API Surface Design
Defined module boundaries for user, product, and transaction endpoints with consistent response contracts.
Signal: Reduced integration ambiguity for client applications - Step 2Service Layering
Applied controller-usecase-repository pattern for clear separation between HTTP handling and business logic.
Signal: Improved maintainability under internship delivery constraints - Step 3Security Baseline
Integrated JWT-based authentication and protected route middleware for sensitive transaction flows.
Signal: Ready-to-extend baseline for role-based access in next iteration
Outcome Snapshot
- Core CapabilityLayered REST API
End-to-end CRUD and transaction pathways implemented
- Auth ScopeJWT-protected routes
Authentication and middleware flow delivered
- Quality SignalStandardized responses
Lowered frontend integration friction
What was delivered and what can be verified
Outcome claims remain conservative and source-backed, while proof records and recruiter-safe links surface the strongest verification trail available.
Validation Signals
- ●Layered architecture is implemented end-to-end.
- ●JWT-based authentication with protected endpoints is documented in the project record.
Source-backed Outcomes
- ●Layered architecture implemented end-to-end
- ●JWT-based authentication with protected endpoints
Proof
- Internship Project
Backend API delivery completed
Rakamin x Evermos
Links
What the project proves, and what it does not
Strong case studies show both what was learned and where the current evidence stops.
Retrospective
Next version should include role-based permissions and broader automated test coverage.
Evidence Limits
- ●Current sources do not provide production traffic, business KPI, or deployment-scale evidence.
- ●The project should remain framed as internship-backed API delivery and architecture proof.
Lessons
- ●Early API response standards reduce frontend integration defects