Panduan ini untuk siapa

• Pembelajar yang siap membangun aplikasi web Python nyata
• Developer yang memilih antara Flask, Django, FastAPI, dan framework lainnya
• Tim yang mengevaluasi pendekatan sync vs async untuk backend service

Apa yang akan Anda pelajari

• Cara memilih framework berdasarkan kebutuhan project
• Perbedaan framework web Python synchronous dan asynchronous
• Trade-off inti Flask, Django, FastAPI, dan Starlette
• Posisi Pyramid, aiohttp, Sanic, Tornado, dan gevent
• Kapan memakai Streamlit atau Dash untuk aplikasi berfokus data

Mengapa topik ini penting

Pilihan framework memengaruhi kecepatan development, fleksibilitas arsitektur, kompleksitas deployment, dan maintainability jangka panjang. Memilih framework yang tepat sejak awal dapat menghemat refactor besar di kemudian hari.

Tidak ada opsi one-size-fits-all. Framework ideal Anda bergantung pada pengalaman tim, kebutuhan performa, kebutuhan ekosistem, dan cakupan produk.

Konsep inti

Kriteria pemilihan framework

Gunakan kriteria ini terlebih dahulu:

• Familiaritas tim dan learning curve
• Fitur bawaan yang dibutuhkan (auth, admin, ORM, routing)
• Profil performa dan kebutuhan concurrency
• Kematangan komunitas dan kualitas dokumentasi

Ini menjaga keputusan tetap objektif dan berorientasi project.

Framework synchronous vs asynchronous

Framework synchronous lebih sederhana untuk banyak aplikasi CRUD. Framework asynchronous membantu beban kerja I/O berkonkurensi tinggi.

Contoh:

• Sync-first: Flask, Django, Pyramid
• Async-capable atau async-first: FastAPI, Starlette, aiohttp, Sanic, Tornado, gevent

Async tidak otomatis lebih baik; sesuaikan dengan workload.

Peran framework yang umum

• Flask: microframework ringan, composition fleksibel
• Django: full-stack framework batteries-included
• FastAPI: modern API-first, ramah async, dokumentasi otomatis
• Streamlit/Plotly Dash: UI data app dan dashboard dengan pengembangan cepat

Pilih berdasarkan jenis produk dan target kecepatan delivery.

Panduan langkah demi langkah

Langkah 1 — Bangun aplikasi kecil pada satu framework

Mulai dengan satu framework dan satu endpoint.

Contoh minimal FastAPI:

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def root():
	return {"message": "Hello from FastAPI"}

Jalankan:

uvicorn main:app --reload

Langkah 2 — Bandingkan dengan framework kedua

Buat endpoint ekuivalen di Flask:

from flask import Flask

app = Flask(__name__)


@app.get("/")
def root():
	return {"message": "Hello from Flask"}


if __name__ == "__main__":
	app.run(debug=True)

Bandingkan ergonomi, default, dan kebutuhan extension.

Langkah 3 — Evaluasi terhadap constraint project nyata

Beri skor kandidat framework berdasarkan:

• Fitur yang dibutuhkan
• Target performa
• Pengalaman tim
• Kecocokan hosting/deployment

Pilih satu dan hindari drift multi-framework kecuali ada alasan kuat.

Contoh praktis

Contoh 1 — Endpoint API dengan validasi (FastAPI)

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
	name: str
	price: float


@app.post("/items")
def create_item(item: Item):
	return {"name": item.name, "price_with_tax": round(item.price * 1.1, 2)}

Expected behavior:

• Payload JSON valid mengembalikan response terhitung.
• Payload tidak valid otomatis mengembalikan validation error.

Contoh 2 — Prototipe data app (Streamlit)

import streamlit as st

st.title("Sales Dashboard")
sales = [120, 150, 170, 160]
st.line_chart(sales)

Jalankan:

streamlit run app.py

Expected result:

• UI browser dengan chart langsung ter-render.

Tabel perbandingan sederhana “Hello World”:

| Framework | Minimal app style | |—|—| | Flask | Route function + app runner | | Django | URL config + view function | | FastAPI | Typed route function + auto docs | | Streamlit | Script-based UI rendering | | Plotly Dash | Declarative dashboard layout + callbacks |

Minimal Plotly Dash hello world:

from dash import Dash, html

app = Dash(__name__)
app.layout = html.Div("Hello from Plotly Dash")

if __name__ == "__main__":
	app.run(debug=True)

Konsep server minimal gaya gevent (green threads):

from gevent import monkey
monkey.patch_all()

from gevent.pywsgi import WSGIServer
from flask import Flask

app = Flask(__name__)

@app.get("/")
def home():
	return {"message": "Hello from gevent"}


if __name__ == "__main__":
	WSGIServer(("0.0.0.0", 8000), app).serve_forever()

Kesalahan umum dan cara menghindarinya

• Memilih framework hanya karena populer -> Tentukan dari kebutuhan dan constraint project.
• Memulai arsitektur async tanpa workload async -> Pakai sync-first untuk sistem yang lebih sederhana.
• Meremehkan nilai fitur bawaan -> Full-stack framework dapat mengurangi boilerplate kustom.
• Mencampur banyak paradigma framework dalam satu project awal -> Jaga arsitektur tetap fokus.

Latihan cepat

• Implementasikan endpoint /health yang sama di Flask dan FastAPI.
• Daftarkan tiga skenario project dan petakan masing-masing ke satu pilihan framework beserta alasannya.
• Bangun mini data app di Streamlit yang menampilkan chart sederhana dan filter.

Ringkasan utama

• Pemilihan framework harus didorong kebutuhan dan dilakukan secara eksplisit.
• Model sync dan async sama-sama punya use case valid.
• FastAPI, Flask, dan Django mencakup sebagian besar kebutuhan backend umum dengan trade-off yang berbeda.
• Data app sering lebih cepat dibangun dengan Streamlit atau Dash.

Langkah berikutnya

Lanjut ke Deployment & Production. Di panduan berikutnya, Anda akan melakukan packaging dan deployment aplikasi Python dengan environment variables, container, dan opsi platform.