[Case Study] The Only Full-Stack Developer in a Marketing Org: A Year at 21N, Decisions and Operations
A case study of how one full-stack developer at a marketing-led company handled ruling out a PG, integrating Modusign e-contracts, cost design, and external integration operations.
Joohwan Yu · Founder, Full Stack Developer
Toris · Published
Contents
This post reorganizes my first year at 21N (21앤), where I worked full-stack across React Native (Expo), NestJS and tRPC, Next.js, and AWS and Terraform, into a case study. The product structure and stack overview are in the platform case study. This post focuses on decisions, coordination, and operations.
Q. What did the only full-stack developer in a marketing-led organization base decisions on?
I reviewed regulation, cost, and external integrations before building features, and I recorded every decision in tables and documents, from ruling out a PG to integrating Modusign, so that nobody had to hear the same explanation twice.
1. Situation: where we started
21N is an organization that grew out of a marketing background, and its engineering staff was thin. Within that, one full-stack developer was responsible for all of the following at the same time.
| Layer | Scope |
|---|---|
| App | React Native (Expo) user app |
| API | Domain API built on NestJS and tRPC |
| Admin | Next.js integrated admin and hospital administrator web |
| Infrastructure | AWS (ECS Fargate, RDS, etc.), Terraform, deployment pipeline |
The reality this creates is clear. An app screen, an API schema, an admin table, and a deployment pipeline issue can all blow up on the same day. Context-switching cost is constant, and there is structurally no time to dig deeply into any one layer. I was aware of the risk that “you look like you can do everything, but the answers get shallow the moment someone asks about one thing in depth.” So I had to choose deliberately what to keep shallow and what to go deep on.
Below is a record of the problems I actually ran into over that year and how I solved each one.
2. Decision 1: how we decided not to attach a PG
We started from the hypothesis that “we just need to plug in a PG for payments.” But a service that ties together hospitals, procedures, and model matching is a different animal from ordinary e-commerce payments, and the review went along three axes.
2.1 Medical regulation
The service is not just a content platform. It touches medicine, procedures, and contracts. On that premise, I worked through keyword by keyword, together with the business and legal sides, how it overlaps with medical law, medical advertising, and brokerage rules. My role on the engineering side was not to interpret the law. It was to ask “what payment and settlement picture is allowed” and to write the answer down.
2.2 PG policies and risk
Depending on industry, product, and settlement structure, a PG often rejects an application, restricts it, or adds extra review. During the review we confirmed in practice that when medical, beauty, and brokerage characteristics are mixed, a PG’s internal risk criteria can close the door entirely.
2.3 Conclusion and aftermath
“Attach a PG and take card payments” only works if law, business, and PG are all YES at the same time, and in our domain that was difficult. So we dropped the PG and locked in the bank-API-based design (account lookup and transfers) that was already aligned with the product direction, and centered e-contracts, points, and settlement on it.
Two principles came out of this. First, if you build the feature first and fit the regulation in afterward, the cost explodes. Second, if you write “why a PG doesn’t work” down on one page, you don’t have to repeat the same explanation to people and outside partners who join later.
3. Decision 2: taking e-contracts to Modusign
E-signatures and e-contracts have to account for legal validity and audit trails, so building them ourselves was too risky. At the company level, we prepared the integration with Modusign: signup, business verification, templates, API, and webhooks. I took on working it into the app, API, and admin.
As the full-stack developer, I paid particular attention to these four things in the integration.
- Environment separation: split API keys, webhook secrets, and template IDs into dev, stage, and prod, and set things up so that production templates can’t be touched by accident
- Webhook idempotency: handle storage, locks, and duplicate keys so that state transitions only once even if the same event arrives several times
- Agreeing on the source of truth for state: explicitly agree with the team on whether to keep intermediate state in our DB between the app and the signature request, or to trust only Modusign’s state
- Observability: use logs to tell where our bug ends and an external issue begins when a signature fails, times out, or is retried
The lesson here is simple. Integrating an external SaaS does not end with “we applied.” The real development starts after registration.
4. Decision 3: making cost a developer’s problem
E-signature SaaS, cloud, and bank integrations all carry per-transaction, monthly, or traffic-based charges. The most worrying situation was “the feature is built, but the operating cost curve is not what we expected,” and I handled it in this order.
- Break cost into numbers. I split monthly fixed costs (seats, subscriptions), per-transaction charges (signatures, API calls), and infrastructure (Fargate, RDS, storage) into a table, and made even a one-page spreadsheet of roughly how much moves in a month if we turn a feature on. It isn’t what a developer wants to do, but it was needed to speak the same language as the PM and the CEO.
- Turn things on in stages. Rather than everything from the start, I enabled only the APIs and templates strictly needed for the MVP phase and blocked the rest with flags and environment variables. Stating “we’ll open it later if needed” in code and configuration cut down on draining debates.
- Cache, batch, async. For work that spends money and time at once, such as PDFs, notifications, and external lookups, I didn’t attach them as synchronous APIs. Queues, workers, and retry policies reduced unnecessary repeat calls. This is a cost issue and a stability issue at the same time.
- Record trade-offs against alternatives. Whenever someone asked something like “isn’t there a cheaper signing SaaS?”, I wrote one line each on legal requirements, audit, integration difficulty, and migration cost, so the decision lives in a table rather than in a hunch.
In the end, full-stack was not a role of just writing code. It was a role of questioning the design down to the unit price. If you hand off cost with “planning will figure it out,” the person who has to explain an API that suddenly gets cut off is still the developer.
5. Moments when the domain came before the technology
21N is a B2B2C business in which e-contracts, points and coupons, bank integration, and hospital, model, and administrator permissions are all tangled together. Knowing the tech stack is different from being able to say “what this state value means to the business right now.”
- When a contract moves from
drafttopending, who should be notified - Should a point payout happen exactly once (idempotency)
- When do the numbers shown in the admin sync with the numbers shown to app users
Sometimes I found these questions late, after the API and the screens had already drifted apart. So I made it a team habit to draw a state diagram or a one-page table before building a feature.
6. Operating external integrations: shrinking the time you can’t tell whose fault it is
With e-signatures, webhooks, and bank APIs, there are long stretches where you can’t tell whether your code is wrong, the sandbox is behaving oddly, or the docs have a gap. Through the Modusign and bank issues, I fixed the following as operating habits.
- Give requests and responses a correlation id to trace the flow
- Keep raw payload logs of external callbacks (masking sensitive data)
- Before saying “can’t reproduce,” first list the time zone, environment, and request body
These habits determined not only debugging speed but also the quality of communication with external partners. When the evidence is organized, the partner’s side confirms the issue much faster.
7. Monorepo: convenience and responsibility come together
When apps/user-app, apps/api, and apps/admin live in one repository, sharing types and constants is easy. In exchange, a single mistake can ripple across several apps. My conclusion from operating it is “share only the minimum.” In many cases a structure with low deployment risk mattered more than perfect DRY.
8. Stakeholder coordination: the real substance of this year
Looking back, I spent more energy on coordination problems than technical ones, and most of what I learned is concentrated there.
8.1 Between a marketing-led organization and a developer
Sharing a desk with people used to campaigns, branding, and client communication, I went through the tension that only shows up when the engineering organization is thin.
- Different languages of expectation: When “launch fast” lined up with the marketing schedule, it took a lot of energy to explain why technical debt, security, and testing are needed.
- Requests from non-engineering backgrounds: Every time, I had to explain that a request like “this is simple, right?” is not simple once it involves data, permissions, and external integrations.
- No fellow developers: The biggest source of stress was that one full-stack developer covered several layers at once and had few people to ask technically.
Two things narrowed this gap. One was practicing how to explain features in the language of the customer journey and conversion rather than “API endpoints.” The other was leaving the reasoning behind decisions in tables, documents, and settings, to eliminate repeat explanations altogether. On a project where outside partners, law, and cost all land on one table, documentation was speed.
8.2 Communication principles
“I don’t want to get caught lacking skill” was the biggest enemy of communication, and I replaced it with these principles.
- 15-minute rule: When stuck, spend 15 minutes on logs, docs, and reproduction, then share the situation with a colleague, even briefly
- Question format: expected behavior / actual behavior / reproduction steps / what I already tried
- PR description: one line on “why I did it this way”
Sharing like this was overwhelmingly better for keeping the schedule than struggling alone.
8.3 Bringing marketing sense into development
I learned something in the other direction too. For in-app consistency to hold when copy, landing pages, and push messages change, development also has to be aware of message versions. It is a sense I gained from working inside a marketing organization.
9. Results: what the year left behind
- Even without a PG, I carried payment, settlement, and contract flows that meet the service’s requirements all the way through in code and infrastructure.
- I worked Modusign into the e-contract pipeline, including application, registration, and integration.
- I organized cost, billing, and staged rollout into tables and settings, reaching a state where I don’t have to repeatedly explain “why we turned it on this way.”
- Inside a marketing-led organization, I built trust as a developer by leaving releases, incident response, and documentation as visible deliverables.
Summary of key decisions
| Decision | Choice | Reason (trade-off) |
|---|---|---|
| PG integration | Don’t attach one; lock in a bank-API-based design | Law, business, and PG all had to be YES at once, which was difficult in our domain. We gave up the convenience of card payments |
| E-contracts | Integrate Modusign (no in-house build) | Delegate legal validity and audit trails to a proven SaaS. Accept per-transaction charges and external dependency |
| Cost management | Break into tables and roll out in stages with flags | Removes draining debates and repeat explanations. Adds non-development work of managing spreadsheets |
| External integration operations | Keep correlation id and raw payload logs | Separate my bugs from external issues in logs to keep partner communication fast. Incurs storage and masking cost |
| Monorepo sharing | Share only the minimum | Prefer a structure with low deployment risk over perfect DRY |
10. Reusable lessons
- People with broad range are needed early, and people with depth in even one area come after. You have to choose deliberately what to go deep on this quarter.
- Full-stack is not a title for doing everything alone. It is closer to a role that translates between cost, regulation, external SaaS, and infrastructure.
- Review regulation, cost, and external integrations before features. The cost of fitting them in afterward is always greater.
- Leave decisions in tables, not in hunches. A one-page document replaces repeat explanations and draining debates.
- When health and sleep collapse, context-switching cost is the first thing to explode. The more a role moves between layers, the more sustainability is productivity.
Closing
21N made me look at domain, regulation, cost, and external integrations all at once, rather than just listing a tech stack. Working as a developer in an organization with strong marketing DNA was not easy, but I learned how to persuade and how to leave documentation behind. I hope this record helps people working under similar conditions: a thin engineering organization, a regulated domain, and a product built around external integrations.
This post is a case study based on my employment experience and is not professional advice on law, tax, PG, or medical regulation. For actual decisions, be sure to go through qualified experts and your company’s internal review. Sensitive details of contracts, security, and internal policy are not included.
Advertisement