🏢 토스 기술 스택 분석

간편송금으로 시작해 종합 금융 플랫폼으로 성장한 토스의 기술 스택을 심층 분석합니다.
"금융의 모든 것, 토스에서" - 기술로 금융을 재정의하는 혁신

📊 회사 개요

서비스 규모

• 월간 활성 사용자: 1,400만+ 명
• 월간 거래: 2억+ 건
• 금융 서비스: 40+ 개
• 연간 거래액: 70조원+
• 직원: 1,800명+

엔지니어링 조직

• 개발자: 600명+ (전체의 35%+)
• 문화: "Move Fast, Think Deep"
• 조직: 목적 조직 (Purpose Organization)
• 기술 철학: 사용자 중심, 데이터 기반

기술적 도전과제

1. 금융 규제 준수: 엄격한 보안/컴플라이언스
2. 대규모 트래픽: 초당 수만 건 거래
3. 무중단 서비스: 24/7 가용성
4. 빠른 성장: 매년 2배 이상 성장

🏗️ 아키텍처 Overview

시스템 다이어그램

┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │Mobile Client│────►│ API │────►│ Service │ │(React Native) │ Gateway │ │ Mesh │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │ │ ┌─────▼─────┐ ┌─────▼─────┐ │ │ Auth │ │ Payment │ │ │ Service │ │ Core │ │ └───────────┘ └───────────┘ │ │ │ └────────────────────┤ │ ┌─────▼─────┐ ┌─────▼─────┐ │ Event │ │ Data │ │ Stream │ │ Platform │ └───────────┘ └───────────┘ 

핵심 설계 원칙

1. Security First: 보안이 최우선
2. Mobile First: 모바일 중심 설계
3. Microservices: 서비스별 독립 배포
4. Event Driven: 이벤트 기반 아키텍처
5. Data Driven: 모든 결정은 데이터로

기술 진화

• 2015-2016: 간편송금 MVP
• 2017-2018: 마이크로서비스 전환
• 2019-2020: 토스뱅크, 토스증권
• 2021-2022: 토스페이먼츠 분사
• 2023-현재: 슈퍼앱화, 해외 진출

🧩 기술 스택 상세

Backend 기술

Node.js 기반 마이크로서비스

// 토스의 결제 처리 서비스 import { Injectable } from "@nestjs/common"; import { EventEmitter2 } from "@nestjs/event-emitter"; import { InjectRepository } from "@nestjs/typeorm"; import { DataSource, EntityManager } from "typeorm"; @Injectable() export class PaymentService { constructor( @InjectRepository(Payment) private paymentRepository: Repository<Payment>, private eventEmitter: EventEmitter2, private dataSource: DataSource, private fraudDetectionService: FraudDetectionService, private notificationService: NotificationService, ) {} async processPayment(request: PaymentRequest): Promise<PaymentResult> { // 분산 트랜잭션 시작 const queryRunner = this.dataSource.createQueryRunner(); await queryRunner.connect(); await queryRunner.startTransaction("SERIALIZABLE"); try { // 1. 멱등성 체크 const existingPayment = await this.checkIdempotency( request.idempotencyKey, ); if (existingPayment) { return existingPayment; } // 2. 사기 탐지 const fraudCheck = await this.fraudDetectionService.analyze({ userId: request.userId, amount: request.amount, recipient: request.recipient, deviceInfo: request.deviceInfo, behaviorPattern: await this.getUserBehaviorPattern(request.userId), }); if (fraudCheck.isHighRisk) { await this.handleHighRiskTransaction(request, fraudCheck); throw new PaymentSecurityException("Security check required"); } // 3. 계좌 잔액 확인 및 보류 const account = await queryRunner.manager.findOne(Account, { where: { userId: request.userId }, lock: { mode: "pessimistic_write" }, }); if (account.balance.lessThan(request.amount)) { throw new InsufficientBalanceException(); } // 4. 결제 생성 const payment = await queryRunner.manager.save(Payment, { id: generateUUID(), userId: request.userId, amount: request.amount, currency: request.currency, recipient: request.recipient, status: PaymentStatus.PENDING, idempotencyKey: request.idempotencyKey, metadata: request.metadata, }); // 5. 잔액 차감 account.balance = account.balance.minus(request.amount); await queryRunner.manager.save(account); // 6. 외부 결제 처리 const externalResult = await this.processExternalPayment(payment); // 7. 결제 완료 처리 payment.status = PaymentStatus.COMPLETED; payment.externalId = externalResult.transactionId; payment.completedAt = new Date(); await queryRunner.manager.save(payment); // 8. 트랜잭션 커밋 await queryRunner.commitTransaction(); // 9. 이벤트 발행 await this.eventEmitter.emitAsync("payment.completed", { paymentId: payment.id, userId: payment.userId, amount: payment.amount, timestamp: payment.completedAt, }); // 10. 알림 발송 await this.notificationService.sendPaymentNotification(payment); return { paymentId: payment.id, status: payment.status, amount: payment.amount, completedAt: payment.completedAt, }; } catch (error) { await queryRunner.rollbackTransaction(); // 보상 트랜잭션 await this.compensateFailedPayment(request, error); throw error; } finally { await queryRunner.release(); } } // 실시간 사기 탐지 private async getUserBehaviorPattern( userId: string, ): Promise<BehaviorPattern> { const recentTransactions = await this.paymentRepository.find({ where: { userId }, order: { createdAt: "DESC" }, take: 100, }); return { averageAmount: this.calculateAverage(recentTransactions), frequency: this.calculateFrequency(recentTransactions), commonRecipients: this.extractCommonRecipients(recentTransactions), unusualPatterns: await this.detectAnomalies(recentTransactions), }; } // 분산 락을 이용한 동시성 제어 async transferMoney( fromUserId: string, toUserId: string, amount: Money, ): Promise<TransferResult> { // Redis 분산 락 획득 const lockKeys = [`account:${fromUserId}`, `account:${toUserId}`].sort(); // 데드락 방지를 위한 정렬 const locks = await Promise.all( lockKeys.map((key) => this.redisLock.acquire(key, 5000)), ); try { // 트랜잭션 실행 return await this.executeTransfer(fromUserId, toUserId, amount); } finally { // 락 해제 await Promise.all(locks.map((lock) => lock.release())); } } } // 이벤트 기반 데이터 동기화 @Injectable() export class DataSyncService { constructor( private readonly kafkaProducer: KafkaProducer, private readonly elasticsearchService: ElasticsearchService, ) {} @OnEvent("payment.completed") async handlePaymentCompleted(event: PaymentCompletedEvent) { // 1. 데이터 웨어하우스 동기화 await this.kafkaProducer.send({ topic: "payment-events", messages: [ { key: event.paymentId, value: JSON.stringify({ eventType: "PAYMENT_COMPLETED", timestamp: event.timestamp, data: event, }), }, ], }); // 2. 검색 인덱스 업데이트 await this.elasticsearchService.index({ index: "payments", id: event.paymentId, body: { userId: event.userId, amount: event.amount, timestamp: event.timestamp, searchableText: this.generateSearchableText(event), }, }); // 3. 실시간 대시보드 업데이트 await this.updateRealtimeDashboard(event); } } 

Kotlin 기반 금융 코어

// 토스뱅크 계좌 시스템 @Service @Transactional class AccountService( private val accountRepository: AccountRepository, private val transactionRepository: TransactionRepository, private val eventPublisher: ApplicationEventPublisher, private val auditService: AuditService ) { suspend fun createAccount(request: CreateAccountRequest): Account { // 본인 인증 확인 val identity = verifyIdentity(request.userId) require(identity.isVerified) { "Identity verification required" } // 중복 계좌 체크 val existingAccount = accountRepository.findByUserId(request.userId) if (existingAccount != null) { throw DuplicateAccountException("Account already exists") } // 계좌 생성 val account = Account( id = generateAccountId(), userId = request.userId, accountNumber = generateAccountNumber(), balance = Money.ZERO, currency = Currency.KRW, status = AccountStatus.ACTIVE, type = request.accountType, createdAt = Instant.now() ) // 저장 val savedAccount = accountRepository.save(account) // 이벤트 발행 eventPublisher.publishEvent( AccountCreatedEvent( accountId = savedAccount.id, userId = savedAccount.userId, accountNumber = savedAccount.accountNumber ) ) // 감사 로그 auditService.log( AuditLog( action = "ACCOUNT_CREATED", entityId = savedAccount.id, userId = request.userId, details = mapOf( "accountType" to request.accountType, "accountNumber" to savedAccount.accountNumber ) ) ) return savedAccount } suspend fun deposit(accountId: String, amount: Money): Transaction { return withTimeout(5000) { // 5초 타임아웃 val account = accountRepository.findByIdWithLock(accountId) ?: throw AccountNotFoundException(accountId) // 입금 한도 체크 val dailyDeposit = transactionRepository .sumDailyDeposits(accountId, LocalDate.now()) if (dailyDeposit + amount > DAILY_DEPOSIT_LIMIT) { throw DepositLimitExceededException( "Daily deposit limit exceeded" ) } // 잔액 업데이트 val previousBalance = account.balance account.balance = account.balance + amount accountRepository.save(account) // 거래 내역 생성 val transaction = Transaction( id = generateTransactionId(), accountId = accountId, type = TransactionType.DEPOSIT, amount = amount, balanceBefore = previousBalance, balanceAfter = account.balance, description = "Deposit", status = TransactionStatus.COMPLETED, createdAt = Instant.now() ) transactionRepository.save(transaction) // 실시간 알림 sendDepositNotification(account.userId, amount) transaction } } // 이체 트랜잭션 @Transactional(isolation = Isolation.SERIALIZABLE) suspend fun transfer( fromAccountId: String, toAccountId: String, amount: Money, description: String? = null ): TransferResult = coroutineScope { // 계좌 조회 (순서 정렬로 데드락 방지) val accountIds = listOf(fromAccountId, toAccountId).sorted() val accounts = accountRepository.findByIdsWithLock(accountIds) val fromAccount = accounts.find { it.id == fromAccountId } ?: throw AccountNotFoundException(fromAccountId) val toAccount = accounts.find { it.id == toAccountId } ?: throw AccountNotFoundException(toAccountId) // 잔액 확인 if (fromAccount.balance < amount) { throw InsufficientBalanceException( "Insufficient balance: ${fromAccount.balance}" ) } // 이체 한도 확인 checkTransferLimit(fromAccount, amount) // 잔액 이동 fromAccount.balance -= amount toAccount.balance += amount // 저장 accountRepository.saveAll(listOf(fromAccount, toAccount)) // 거래 내역 생성 (병렬 처리) val (withdrawalTx, depositTx) = awaitAll( async { createTransaction( fromAccount, TransactionType.WITHDRAWAL, -amount, description ?: "Transfer to ${toAccount.accountNumber}" ) }, async { createTransaction( toAccount, TransactionType.DEPOSIT, amount, description ?: "Transfer from ${fromAccount.accountNumber}" ) } ) TransferResult( transferId = generateTransferId(), fromTransaction = withdrawalTx, toTransaction = depositTx, amount = amount, completedAt = Instant.now() ) } } // 실시간 거래 모니터링 @Component class TransactionMonitor( private val redisTemplate: RedisTemplate<String, String>, private val alertService: AlertService ) { private val suspiciousPatterns = listOf( // 연속된 소액 이체 Pattern { transactions -> transactions.size >= 10 && transactions.all { it.amount < Money(10000, Currency.KRW) } && transactions.distinctBy { it.toAccountId }.size == 1 }, // 새벽 시간 대량 이체 Pattern { transactions -> val nightTransactions = transactions.filter { val hour = it.createdAt.atZone(ZoneId.of("Asia/Seoul")).hour hour in 0..6 } nightTransactions.sumOf { it.amount } > Money(10000000, Currency.KRW) }, // 급격한 패턴 변화 Pattern { transactions -> val recent = transactions.take(10) val historical = transactions.drop(10).take(90) val recentAvg = recent.map { it.amount }.average() val historicalAvg = historical.map { it.amount }.average() recentAvg > historicalAvg * 10 } ) @EventListener fun onTransaction(event: TransactionEvent) { runBlocking { // 최근 거래 내역 조회 val recentTransactions = getRecentTransactions(event.userId, 100) // 패턴 분석 val detectedPatterns = suspiciousPatterns .filter { pattern -> pattern.matches(recentTransactions) } if (detectedPatterns.isNotEmpty()) { // 위험도 계산 val riskScore = calculateRiskScore(detectedPatterns, recentTransactions) if (riskScore > 0.7) { // 거래 차단 blockUserTransactions(event.userId) // 알림 발송 alertService.sendHighRiskAlert( userId = event.userId, riskScore = riskScore, patterns = detectedPatterns ) } } } } } 

Mobile 기술 (React Native)

크로스 플랫폼 앱

// 토스 React Native 앱 import React, { useEffect, useState } from "react"; import { View, Text, TouchableOpacity, Animated, PanResponder, } from "react-native"; import BiometricAuth from "react-native-biometrics"; import { useRecoilState } from "recoil"; // 생체 인증 Hook export const useBiometricAuth = () => { const [isAuthenticated, setIsAuthenticated] = useRecoilState(authState); const authenticate = async (): Promise<boolean> => { try { const { available, biometryType } = await BiometricAuth.isSensorAvailable(); if (!available) { throw new Error("Biometric authentication not available"); } const { success, signature } = await BiometricAuth.createSignature({ promptMessage: "토스 앱 잠금해제", cancelButtonText: "취소", }); if (success) { // 서버 검증 const verified = await verifyBiometricSignature(signature); setIsAuthenticated(verified); return verified; } return false; } catch (error) { console.error("Biometric auth failed:", error); return false; } }; return { authenticate, isAuthenticated }; }; // 송금 화면 컴포넌트 export const TransferScreen: React.FC = () => { const [amount, setAmount] = useState(""); const [recipient, setRecipient] = useState<User | null>(null); const slideAnim = useRef(new Animated.Value(0)).current; const { authenticate } = useBiometricAuth(); // 스와이프하여 송금 제스처 const panResponder = useRef( PanResponder.create({ onStartShouldSetPanResponder: () => true, onPanResponderMove: (_, gestureState) => { if (gestureState.dx > 0) { slideAnim.setValue(gestureState.dx); } }, onPanResponderRelease: (_, gestureState) => { if (gestureState.dx > 200) { // 송금 실행 executeTransfer(); } else { // 원위치로 Animated.spring(slideAnim, { toValue: 0, useNativeDriver: true, }).start(); } }, }) ).current; const executeTransfer = async () => { try { // 생체 인증 const authenticated = await authenticate(); if (!authenticated) { showError("인증에 실패했습니다"); return; } // 송금 API 호출 const result = await transferAPI.send({ toUserId: recipient.id, amount: parseAmount(amount), currency: "KRW", }); // 성공 애니메이션 await showSuccessAnimation(); // 결과 화면으로 이동 navigation.navigate("TransferComplete", { result }); } catch (error) { handleTransferError(error); } }; return ( <SafeAreaView style={styles.container}> <TransferHeader recipient={recipient} /> <AmountInput value={amount} onChange={setAmount} currency="KRW" /> <View style={styles.swipeContainer}> <Animated.View {...panResponder.panHandlers} style={[ styles.swipeButton, { transform: [{ translateX: slideAnim }], }, ]} > <Text style={styles.swipeText}>밀어서 송금</Text> </Animated.View> </View> <RecentTransfers onSelectRecipient={setRecipient} /> </SafeAreaView> ); }; // 실시간 자산 현황 export const AssetDashboard: React.FC = () => { const [assets, setAssets] = useState<Asset[]>([]); const [totalValue, setTotalValue] = useState(0); useEffect(() => { // WebSocket 연결로 실시간 업데이트 const ws = new WebSocket("wss://api.toss.im/assets/stream"); ws.onmessage = (event) => { const update = JSON.parse(event.data); switch (update.type) { case "BALANCE_CHANGE": updateAssetBalance(update.assetId, update.newBalance); break; case "PRICE_CHANGE": updateAssetPrice(update.assetId, update.newPrice); break; case "NEW_TRANSACTION": addTransaction(update.transaction); break; } }; return () => ws.close(); }, []); return ( <ScrollView style={styles.dashboard}> <TotalAssetCard value={totalValue} /> <SectionTitle>내 자산</SectionTitle> {assets.map((asset) => ( <AssetCard key={asset.id} asset={asset} onPress={() => navigateToAssetDetail(asset)} /> ))} <SectionTitle>투자 상품</SectionTitle> <InvestmentProducts /> <InsightCard title="이번 달 소비 분석" insight={generateSpendingInsight()} /> </ScrollView> ); }; // 보안 모듈 class SecurityModule { private static instance: SecurityModule; private jailbreakDetected = false; private appTampered = false; static getInstance(): SecurityModule { if (!this.instance) { this.instance = new SecurityModule(); } return this.instance; } async initialize() { // 탈옥/루팅 탐지 this.jailbreakDetected = await this.detectJailbreak(); // 앱 무결성 검증 this.appTampered = await this.verifyAppIntegrity(); // 보안 위협 감지 시 종료 if (this.jailbreakDetected || this.appTampered) { Alert.alert("보안 경고", "보안 위험이 감지되어 앱을 종료합니다.", [ { text: "확인", onPress: () => RNExitApp.exitApp() }, ]); } // SSL Pinning 설정 await this.setupSSLPinning(); // 화면 캡처 방지 this.preventScreenCapture(); } private async detectJailbreak(): Promise<boolean> { // iOS if (Platform.OS === "ios") { const suspiciousPaths = [ "/Applications/Cydia.app", "/Library/MobileSubstrate/MobileSubstrate.dylib", "/bin/bash", "/usr/sbin/sshd", "/etc/apt", ]; for (const path of suspiciousPaths) { if (await RNFS.exists(path)) { return true; } } } // Android if (Platform.OS === "android") { const rootBinaries = [ "/system/app/Superuser.apk", "/sbin/su", "/system/bin/su", "/system/xbin/su", "/data/local/xbin/su", ]; for (const binary of rootBinaries) { if (await RNFS.exists(binary)) { return true; } } } return false; } } 

데이터 플랫폼

실시간 분석 시스템

# 토스 데이터 파이프라인 from pyspark.sql import SparkSession from pyspark.sql.functions import * from pyspark.sql.types import * import mlflow class TossDataPipeline: def __init__(self): self.spark = SparkSession.builder \ .appName("TossRealtimeAnalytics") \ .config("spark.sql.adaptive.enabled", "true") \ .config("spark.sql.adaptive.coalescePartitions.enabled", "true") \ .getOrCreate() def process_transaction_stream(self): # Kafka 스트림 읽기 transaction_stream = self.spark \ .readStream \ .format("kafka") \ .option("kafka.bootstrap.servers", "kafka-cluster:9092") \ .option("subscribe", "transactions") \ .option("startingOffsets", "latest") \ .load() # 스키마 정의 transaction_schema = StructType([ StructField("transaction_id", StringType()), StructField("user_id", StringType()), StructField("amount", DoubleType()), StructField("currency", StringType()), StructField("type", StringType()), StructField("timestamp", TimestampType()), StructField("merchant_id", StringType()), StructField("category", StringType()) ]) # 파싱 및 변환 parsed_stream = transaction_stream \ .select(from_json(col("value").cast("string"), transaction_schema).alias("data")) \ .select("data.*") \ .withWatermark("timestamp", "10 minutes") # 실시간 집계 # 1. 사용자별 지출 패턴 user_spending = parsed_stream \ .groupBy( window("timestamp", "1 hour"), "user_id", "category" ) \ .agg( sum("amount").alias("total_spent"), count("transaction_id").alias("transaction_count"), avg("amount").alias("avg_transaction") ) # 2. 이상 거래 탐지 anomaly_detection = parsed_stream \ .groupBy( window("timestamp", "5 minutes"), "user_id" ) \ .agg( sum("amount").alias("total_amount"), count("transaction_id").alias("count"), stddev("amount").alias("amount_stddev") ) \ .filter( (col("total_amount") > 10000000) | # 1천만원 이상 (col("count") > 50) | # 5분간 50건 이상 (col("amount_stddev") > 1000000) # 표준편차 100만원 이상 ) # 결과 저장 # 1. 실시간 대시보드용 Redis user_spending.writeStream \ .foreachBatch(lambda df, epoch_id: self.write_to_redis(df, "user_spending")) \ .outputMode("update") \ .start() # 2. 이상 거래 알림 anomaly_detection.writeStream \ .foreachBatch(lambda df, epoch_id: self.send_anomaly_alerts(df)) \ .outputMode("update") \ .start() # 3. 데이터 웨어하우스 저장 parsed_stream.writeStream \ .format("delta") \ .option("checkpointLocation", "/checkpoints/transactions") \ .option("path", "/data/warehouse/transactions") \ .partitionBy("timestamp") \ .start() self.spark.streams.awaitAnyTermination() def train_fraud_detection_model(self): # 학습 데이터 로드 training_data = self.spark.read \ .format("delta") \ .load("/data/warehouse/transactions") \ .filter(col("label").isNotNull()) # 특징 엔지니어링 feature_data = training_data \ .withColumn("hour_of_day", hour("timestamp")) \ .withColumn("day_of_week", dayofweek("timestamp")) \ .withColumn("amount_log", log(col("amount") + 1)) \ .withColumn("user_avg_amount", avg("amount").over(Window.partitionBy("user_id"))) \ .withColumn("amount_deviation", col("amount") - col("user_avg_amount")) # ML 파이프라인 from pyspark.ml import Pipeline from pyspark.ml.feature import VectorAssembler, StandardScaler from pyspark.ml.classification import GBTClassifier assembler = VectorAssembler( inputCols=[ "amount_log", "hour_of_day", "day_of_week", "amount_deviation", "transaction_count_1h" ], outputCol="features" ) scaler = StandardScaler( inputCol="features", outputCol="scaled_features" ) gbt = GBTClassifier( featuresCol="scaled_features", labelCol="is_fraud", maxDepth=5, maxIter=100 ) pipeline = Pipeline(stages=[assembler, scaler, gbt]) # 모델 학습 model = pipeline.fit(feature_data) # MLflow로 모델 저장 with mlflow.start_run(): mlflow.spark.log_model(model, "fraud_detection_model") mlflow.log_metric("auc", 0.95) mlflow.log_metric("precision", 0.92) mlflow.log_metric("recall", 0.89) return model 

기술 스택 요약:

• Backend: Node.js (TypeScript), Kotlin, Python
• Frontend: React Native, React
• 데이터베이스: PostgreSQL, MongoDB, Redis
• 메시지큐: Kafka, RabbitMQ
• 인프라: AWS, Kubernetes
• 데이터: Spark, Airflow, Delta Lake
• 모니터링: Datadog, Sentry
• 보안: Vault, AWS KMS

💡 핵심 기술 인사이트

1. 모바일 퍼스트 전략

• React Native로 빠른 개발
• 네이티브 수준 성능
• 일관된 사용자 경험

2. 마이크로서비스 아키텍처

• 서비스별 독립 배포
• 장애 격리
• 빠른 개발 속도

3. 실시간 데이터 처리

• 스트리밍 아키텍처
• 실시간 이상 탐지
• 즉각적인 인사이트

📈 성과 & 지표

기술적 성과

• 앱 구동 시간: < 1초
• API 응답시간: P50 < 100ms
• 시스템 가용성: 99.99%
• 일일 배포: 50+ 회
• 장애 복구시간: < 5분

비즈니스 영향

• MAU: 1,400만+ (한국 경제활동인구 50%+)
• 누적 송금액: 180조원+
• 기업 가치: 8조원+ (유니콘)
• 금융상품 가입자: 500만+

🎓 토스에서 배울 점

✅ 적용 가능한 패턴

1. 간단한 UX: 복잡한 금융을 쉽게
2. 빠른 반복: 주간 단위 릴리즈
3. 데이터 기반: A/B 테스트 문화
4. 보안 우선: 제로 트러스트
5. 목적 조직: 자율과 책임

❌ 주의사항

1. 규제 대응: 금융 규제 변화
2. 보안 요구사항: 극도로 높은 기준
3. 확장성: 급성장에 따른 부담
4. 기술 부채: 빠른 성장의 부작용

📚 추천 리소스

• 토스 기술 블로그
• 토스 디자인 시스템
• SLASH 컨퍼런스
• 토스 오픈소스

🔮 미래 전망

현재 집중 분야

1. 토스뱅크: 인터넷 전문은행
2. 토스증권: 모바일 투자
3. 토스페이: B2B 결제
4. 해외 진출: 베트남, 일본
5. Web3: 블록체인, 암호화폐

기술 투자 영역

• AI/ML: 개인화 금융 서비스
• 블록체인: DeFi, CBDC
• 오픈뱅킹: API 플랫폼
• 빅데이터: 신용평가 고도화
• 클라우드: 멀티 클라우드

"누구나 쉽게 금융 서비스를 이용할 수 있는 세상을 만들어갑니다."

• 토스 기술 조직

마지막 업데이트: 2025-01-28