Skip to main content
강홍재/ James
← Work
EMBA2026 · PM · Developer· Started(First Commit date)

EMBA E-Members

A community app for SKKU EMBA members - the member directory, business-card QR sharing, mentoring, schedule, board, and cafeteria menu in one place.

  • Flutter
  • Firebase
  • iOS
  • Android
Screenshots
  • My page - manage academic, club, and company info in one place, with QR business card and profile editing

  • Business card sharing - scanning my QR opens the EMBA app, or falls back to a web business card if the app isn't installed

  • Cafeteria menu - browse the school cafeteria menu by week, with photos

Setup

Problem

An EMBA peer network is itself an asset, but that asset ends up scattered across KakaoTalk rooms, spreadsheet rosters, paper business cards, and school notice emails. "Which cohort was that person again?", "where's that notice?", "what's for lunch today?" each become a hunt through separate channels. What members need isn't flashy features but the basics - "find people, exchange cards, and don't miss the schedule or news, all in one place."

Context

The official member community app for SKKU EMBA. Built by a small team - 1 PM and 2 developers - with James as the PM and one of the developers: defining the feature scope and priorities, and developing and maintaining the inherited Flutter codebase, shipping and updating on both the iOS and Android stores (currently v1.1.5, build 21). The focus was making the basics solid first - finding people, exchanging cards, schedule and notices - so a single member can rely on it end to end.

Users

Current and graduated SKKU EMBA members, plus cohort organizers.

Hypothesis

Let members handle people, cards, schedule, and news in one app instead of scattered channels, and the EMBA network becomes an asset that actually reaches you when you need it.

Build

What I did
  • As PM, defined feature scope and priorities and ran releases/updates on both the iOS and Android stores
  • Took over the existing Flutter codebase and co-develop/maintain it (currently v1.1.5, build 21)
  • Member directory - search and filter by cohort, job field, and name, and save a member's profile straight into the phone's contacts
  • Business-card QR sharing - scanning opens the EMBA app, with a fallback to a web business card if the app isn't installed
  • Mentoring - find and request a mentor, with 1:1 chat
  • Schedule calendar (academic, cohort, personal), board and notices (with a built-in PDF viewer for attachments), school news and webzine (WebView), and a weekly cafeteria menu
  • FCM push notifications and KO/EN localization
Product decisions
  • Basics first - finding people, cards, schedule, and notices made solid before any flashy social features
  • Cards as QR plus a web fallback - so a card still gets delivered even if the other person hasn't installed the app; no forcing an install in a networking moment
  • Save contacts into the phone's native address book - an asset that stays even after leaving the app
  • A single iOS/Android codebase (Flutter) - so a small team can maintain both platforms at once
QA considerations
  • The boundaries of inherited code (token expiry/re-login, network failures, empty states, missed push) hold up in real members' hands, not just a demo
  • Business-card QR - when the other person hasn't installed the app, the mobile-browser web fallback still delivers the card
  • The single Flutter codebase behaves identically on iOS and Android (including deep links and push)
  • The proactively-found security issues (plaintext passwords, sensitive data in logs, exposed keys) are verified as actually closed
  • Inherited with no regression tests on the core flows (login, push, member search) - where is "same input, same result" guaranteed?

Outcome

Metrics

A live service for SKKU EMBA members. Deployed and in use on both the iOS and Android stores (currently v1.1.5, build 21). Detailed usage metrics are private.

Result / Learning

Confirmed the weight of taking over and running code I didn't write. Adding a new feature is easy; the real cost on inherited code is that "if I change this, what else breaks?" isn't visible. So the conclusion was that mapping the boundaries of the core flows (login, push, member search) comes before taking feature requests. The next round starts by laying regression tests on those boundaries.

Retrospective
  • Right after the handover I started taking feature requests; I should have mapped the code's boundaries first. Stacking features on code you don't know makes regressions impossible to predict.
  • It was inherited with almost no automated tests. I should have laid regression tests on the core paths earlier.

PM role (de facto)

Formally a frontend dev, but I filled the vacant PM function - handover, schedule, quality, release, and stakeholder reporting.

My formal role on the team was frontend development (Flutter). But the PM functions - task allocation, schedule and risk management, progress visibility, stakeholder reporting - were vacant, so I filled that gap in practice while developing. I took over the app the previous vendor had built, analyzed it, and pulled the scattered requirements, schedule, access, quality, and release into one thread - shipping to both the iOS and Android stores at the same time, just before the student council's term ended, in about two months. Below is the record of that PM role.

Project handover & access transfer

I took on the messiest, most important work at the start: turning someone else's code and scattered ops access into a state I could actually control.

  • Audited the entire existing codebase I hadn't written and listed the fixes/refactors (accepting the handicap that inherited code takes longer)
  • Stood up and migrated three new GitHub repos - app, admin, backend
  • Cleaned up AWS access - identified and escalated RDS / IP-whitelist issues
  • Secured Google Play Console admin rights and confirmed the vendor's access was revoked
  • Invited an Apple Developer team admin, revoked and reissued the signing key (.p8), removed the vendor's member, and checked the distribution certificates
  • Volunteered to take on the backend too where things stalled, to cover the scope gap

Skills · Schedule · Prioritization · Risk · Resourcing

Scoping & requirements alignment

  • Fixed scattered discussions into meeting notes and an agreed scope
  • Made "hand it over spec-complete" the principle for the handover, which surfaced key spec gaps to re-align on
  • Parked the cafeteria-menu feature while its decision lagged, and finished the search/filter, webzine, and business-card UI first to stop the delay from spreading

Skills · Scoping · Scope alignment

Schedule & bottleneck management

  • Built and ran a schedule worked backward from the deadline
  • Split the backend bottleneck into discrete tasks and reported progress transparently
  • Answered stakeholders' schedule questions item by item, and reframed vague questions into answerable ones before answering

Skills · Schedule · Bottleneck management

Visibility & stakeholder communication

I was the translator and single reporting channel between the dev team and the non-technical student council.

  • Ran a status board - done / in progress / not started, frontend and backend split out, existing vs. added requirements distinguished
  • Shared a daily progress report with the whole council, written in language a non-developer could follow
  • Surfaced risks and constraints rather than hiding them, always paired with a set of realistic options (re-outsource / adjust scope / re-prioritize)
  • Under pressure, took responsibility first and pivoted to prevention

Skills · Stakeholder management · Reporting · Expectation setting

Quality & security

I applied fourteen years of QA even outside the requested scope.

  • Proactively found and fixed 6+ security issues outside the request (plaintext passwords, sensitive data in logs, exposed keys, etc.)
  • Built a test environment for non-developers - Firebase App Distribution, tester registration, demo videos
  • Wrote the QA reports and test guides myself

Skills · Quality · Security · Test environment

Release

I carried the simultaneous iOS/Android launch across the line, just before the term ended.

  • Set up and deployed a dedicated business-card domain with deep links and app auto-open - so even non-members without the app could view a card
  • Knowing the "avoid Friday/weekend releases" rule, still decided on a Friday release - conditioned on monitoring - to ship within the term
  • Result: on 2026-06-25 both the Android and iOS reviews were approved and shipped the same day

Skills · Release · App-store ops · Infra decisions

Operations handover & sustainability

I closed this out not by "ending" it but by making it something the next owners could pick up.

  • Cafeteria menu - documented the missing-data and undecided-owner issues, and proposed a phased plan (frontend done now, backend over the break)
  • Took direct ownership of the handover discussion with the next (66th) student council and its president
  • Surfaced ops-efficiency ideas like auto-checking club-fee payment status
  • Handled many usability improvements - auto-saving contacts, card layout, consistent labeling for members with no employer

Skills · Operations transition · Handover · Product improvement

Collaboration with the backend dev (self-assessment)

I'm not a frontend dev by background and doubted I could collaborate well - a self-assessment grounded in the backend collaboration channel logs: strengths and growth areas.

I'm not a frontend developer by background, so I doubted whether I could collaborate well with the backend. So I reviewed how I actually worked, grounded in the backend collaboration channel logs (about two weeks). Looking back, what kept the collaboration running wasn't "frontend coding skill" but thinking in interfaces, requirements discipline, issue tracking, quality gates, prioritization, and how I treated people - the very things developers who've only gone deep in one area are often weak at. I wrote down both what went well and what to improve.

  • Interface / dependency thinking★★★★★
  • Collaboration tools & protocol★★★★★
  • Closing ambiguity with evidence★★★★☆
  • Quality / release gatekeeping★★★★★
  • Prioritization & focus★★★★☆
  • Tone & psychological safety★★★★☆
  • Text communication tone · in text, room to soften the tone★★★☆☆

Strengths

Thinks in interfaces

I treated the FE/BE boundary as a contract - settling what gets exchanged and the dependencies first, before starting the work.

Fluent with collaboration tools and protocol

I specified the APIs I needed down to endpoints and field lists, and when a subdomain issue blocked us I built a small express server myself and pushed it to the repo to unblock proactively. I attached screenshots as evidence.

Closes ambiguity with evidence

For a vague issue - "a certain cohort doesn't appear in the search dropdown" - I went hypothesis -> hands-on test -> reading the actual code (the cohort field is nullable, so it had been registered as "not selected"), and concluded "no fix needed, leave as is." I also split what to do now from what to improve later (make it required, CSV bulk import, etc.).

Holds the quality and release gate

When the backend announced a production deploy, I asked for a QA / integration check gate before shipping, stopping a deploy with no verification. The most striking part of the collaboration.

Creates psychological safety

I admitted my own mistakes first ("I think I missed that") and didn't push the fix burden onto the other person ("it's structurally fine, better that I handle it"). As a result, they too could name their own mistakes without getting defensive.

Growth areas

Polishing the text tone behind a fast urge to confirm

When I spot an issue, I have a strong urge to confirm and pin it down quickly. In person that reads as drive, but in text the same intent can come across drier, so taking one more pass on tone makes collaboration smoother.

Try Adding one line - "I think I lost the context here; could you walk me through it once?" - gets the same information across more gently.

Tech stack
  • Flutter
  • Dart
  • Firebase Cloud Messaging
  • REST API (dio)
  • Hive
  • get_it
  • easy_localization
  • WebView
  • iOS
  • Android