[Case Study] Four Months at Semware: A Renewal, an Education Platform, a Legacy Migration, and the Move to SM Full-Stack
A case study of four months at Semware (셈웨어): a website renewal, an education content platform, a legacy API migration, and the shift to full-stack on the Itda SM project, focused on constraints, design decisions, and coordination.
Joohwan Yu · Founder, Full Stack Developer
Toris · Published
Contents
This post is a case study of projects Toris’s CEO worked on while employed at Semware (셈웨어). For security reasons, specific project details are left out, and the record focuses on technical decisions and the collaboration process.
Q. How did you migrate a live legacy system within four months?
Instead of a big-bang rewrite, I chose feature-by-feature incremental migration so that every step could be rolled back, and I used type definitions as the design document to keep risk under control.
1. Background: What I Was Asked to Do
| Item | Details |
|---|---|
| Company | Semware (셈웨어) |
| Period | Aug 2024 – Dec 2024 (about 4 months) |
| Role | Frontend developer (React), later full-stack on the Itda (잇다) SM project |
| Main technologies | React, TypeScript, Spring, MyBatis |
My work at Semware split into two phases. At first I focused on React-based frontend development: a website renewal, an education content platform, and a legacy migration. Later, after a team reorganization, I joined the Itda SM project, and my scope widened to full-stack work that included the Spring backend.
The stack I used was as follows.
| Area | Stack |
|---|---|
| Frontend | React, TypeScript, Next.js, styled-components, Tailwind CSS, Zustand |
| Backend | Spring Framework, Spring Boot, MyBatis, iBatis |
| Legacy | JSP, jQuery |
| DB | MariaDB, MySQL |
2. Constraints
- Coexisting with the legacy system: An existing system built on JSP, jQuery, and iBatis was in production. New development could not tear it out all at once. It had to be converted incrementally while keeping operations running.
- A maintenance (SM) project: Itda SM was not a new product. It was about maintaining and improving a system already in operation. Every change reached real users immediately, so minimizing risk came first.
- Collaboration across many roles: With PMs, designers, and outside vendors involved, the frontend had to act as the point of contact.
- Short timeline, wide scope: In about four months I had to deliver several frontend projects and also make the move to full-stack.
3. Design and Trade-offs by Project
3.1 React-based website renewal
The first main project I took on after joining was a website renewal.
Design decisions
- I rebuilt the screens with component-based development on React and styled-components. In practice I saw firsthand that CSS-in-JS improves cohesion between components and styles, but comes with runtime cost and a learning curve. That gave me a basis for choosing between it and utility CSS (Tailwind) on later projects.
- I set mobile-first responsive design as the baseline and built accessibility, such as semantic HTML and keyboard navigation, into the initial design. Accessibility costs less when it is included from the start than when it is bolted on later.
- I handled performance through image optimization, code splitting, and preventing unnecessary re-renders with
React.memo.
Trade-off: I chose incremental migration over a full rewrite. Moving off the existing embedded library toward an API-based approach was happening in parallel, so converting in stages carried lower operational risk than replacing everything at once.
3.2 Education content platform
I took part in developing an education content platform with React and TypeScript.
Design decisions
- Separating domain data from user state: I structurally separated domain data such as questions and answers from the user’s solving state, so that state changes would not contaminate the domain data.
- Zustand + persist middleware: I managed global state with Zustand and connected it to sessionStorage through the persist middleware. The solving state survives a refresh without any separate serialization code.
- Using the Record type: A
Record-based state structure keyed by question ID lowered lookup and update costs and gave me type safety. - Theme system: I separated the elementary and middle school themes using the Context API, so the same component gets different styles depending on the target grade. Once the themes were built as a system, maintenance cost dropped noticeably.
What this project confirmed for me is that, the more complex the domain, the more type definitions become the design document. Once you make the types clear first, the component structure and state boundaries follow naturally.
3.3 Legacy migration: from an embedded library to an API
This was the work of converting an existing embedded library into an API-based service.
Order of work
- Legacy code analysis: I spent time first on understanding the existing behavior accurately
- API endpoint design: defined data structures that are easy for the frontend to consume
- Incremental migration strategy: converted feature by feature while keeping the existing path
- Frontend-API integration and type definitions
Trade-off: I ruled out a big-bang conversion because the verification scope could not be controlled. Incremental conversion takes longer, but you can roll back at each step, which was the right fit for a system in operation. I also confirmed in practice that clearly defining API response types lets you catch integration mistakes at compile time.
3.4 Itda SM project: from frontend to full-stack
After about four months focused on the frontend, I joined the Itda SM project following a team reorganization and widened my responsibilities to include the backend.
Responsibilities
- Backend API development on the Spring Framework
- Database integration through MyBatis XML mappers
- Frontend-backend integration
- Security feature implementation, including an OTP authentication system
- Event system design and development
What I gained from the move to full-stack
- I got the whole flow of how the frontend and backend connect into one person’s field of view. The biggest change is that, when designing APIs afterward, I could use “which data structure is easiest from a frontend developer’s point of view” as my criterion.
- I learned Spring’s DI (dependency injection) and IoC concepts and writing MyBatis XML mappers at a working level, and confirmed that SQL query optimization translates directly into screen performance.
- Implementing OTP authentication gave me an understanding of the difference between authentication and authorization and of security flows in general. This was the stretch where I learned that for security features, the bar for “working” and the bar for “secure” are different.
4. Coordinating with Stakeholders
What stayed with me longer than the technology was how to work with people in different roles.
4.1 With designers
In the flow of receiving Figma mockups and implementing them, what mattered more than building to the mockup was sharing technical constraints early. If you say “this is hard” during implementation, both sides’ work gets sent back. If you share the constraints at the mockup stage, the design side can reflect alternatives first. I also confirmed that understanding the design system and keeping styles consistent contributes more to overall quality than the polish of any individual screen. Working this way noticeably raised my understanding of UI/UX.
4.2 With PMs and outside vendors
In a setup where PMs, designers, and outside vendors are all involved, the ability to explain without technical jargon was effectively the speed of the project. Even the same feature has to be translated into the other person’s language before decisions get made faster. Keeping each role aware of the others’ status through regular meetings and progress updates sounds obvious, but I learned on a multi-role project that when this breaks down, the schedule breaks down with it.
4.3 The production system as a stakeholder
On an SM project, “the users using it right now” are the biggest stakeholder. Preserving existing behavior takes priority over new features, so spending time on legacy analysis first and converting incrementally were not mere preferences but requirements of the production environment.
5. Results and Operations
- I completed the website renewal with a component-based, responsive, accessibility-aware structure, and ran in parallel a migration that moved the embedded library dependency to an API-based approach.
- I built a domain/state separation structure and a theme system into the education content platform to secure maintainability.
- On the Itda SM project, I developed and integrated backend features such as OTP authentication and the event system, expanding my role from frontend-only to full-stack.
What I Left as Limitations
There are also parts I should leave in honestly for a case study.
| Item | What was lacking | How it changed afterward |
|---|---|---|
| Test code | I focused on verifying that features worked and could not write tests in most projects | Established a standard of counting tests as part of the schedule |
| Documentation | I often found myself asking later, “why was this code written this way?” | A habit of leaving the reasons for decisions alongside the code |
| Performance monitoring | There was no system for measuring the performance real users experience | A principle of not optimizing without measuring |
| Code quality | Duplicated code and insufficient error handling | Designing error paths with the same weight as happy paths |
Summary of Key Decisions
| Decision | Choice | Reason (trade-off) |
|---|---|---|
| Legacy migration approach | Incremental migration instead of big-bang | Each step can be rolled back, so operational risk is low. The overall timeline gets longer |
| Styling (renewal) | CSS-in-JS with styled-components | Gets cohesion between components and styles. Accepts the runtime cost and learning curve |
| State management (education platform) | Zustand + persist (sessionStorage) | Solving state survives a refresh without separate serialization code. Dependence on global state increases |
| Theme handling | Context API-based theme system | Systematizing the elementary/middle school style branching reduces maintenance cost. Initial design cost increases |
| Role scope | Accepted the move from frontend-only to full-stack | Gained the whole frontend-backend flow in one view. Gave up some time to go deep on a single layer |
6. Reusable Lessons
- Incremental migration is not a preference but a requirement of the production environment. On a system in operation, converting in units that can be rolled back is the essence of risk management.
- Type definitions are design. The more complex the domain, the more that making types clear first brings state boundaries and component structure along with it.
- Design APIs from the consumer’s point of view. Having built a backend myself gives me a standard for designing APIs from the frontend’s perspective.
- Share constraints at the mockup stage, not the implementation stage. Most friction with designers and PMs comes from information arriving late.
- The ability to translate into non-developers’ language determines schedule speed. This is especially true the more roles a project involves.
- Regrets become the standard for the next project. Testing, documentation, monitoring, and error handling: the items I was weak on in this period became the default checklist for later projects.
This post is a case study compiled from my experience during my employment, and for security reasons it does not include specific project details.
Advertisement