diff --git a/javascript/.env b/javascript/.env
new file mode 100644
index 0000000..e69de29
diff --git a/javascript/src/App.tsx b/javascript/src/App.tsx
new file mode 100644
index 0000000..696d508
--- /dev/null
+++ b/javascript/src/App.tsx
@@ -0,0 +1,45 @@
+import React, { useEffect, useState } from "react";
+import PostList from "./components/PostList";
+import PostForm from "./components/PostForm";
+import ErrorBanner from "./components/ErrorBanner";
+import Loader from "./components/Loader";
+import { getPosts } from "./api/client";
+import type { Post, ApiError } from "./api/types";
+
+const App: React.FC = () => {
+  const [posts, setPosts] = useState<Post[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+
+  const fetchPosts = async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await getPosts();
+      setPosts(data);
+    } catch (err) {
+      const apiError = err as ApiError;
+      setError(apiError.message || "API unavailable");
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    fetchPosts();
+  }, []);
+
+  return (
+    <main className="min-h-screen bg-gray-100">
+      {error && <ErrorBanner message={error} />}
+      <div className="max-w-2xl mx-auto py-8 px-2 flex flex-col gap-6">
+        <h1 className="text-3xl font-bold text-center">Simple Social Media</h1>
+        <PostForm onPostCreated={fetchPosts} />
+        {loading ? <Loader /> : <PostList posts={posts} />}
+      </div>
+    </main>
+  );
+};
+
+export default App;
diff --git a/javascript/src/api/client.ts b/javascript/src/api/client.ts
new file mode 100644
index 0000000..49f2976
--- /dev/null
+++ b/javascript/src/api/client.ts
@@ -0,0 +1,113 @@
+import type {
+  Post,
+  PostCreate,
+  PostUpdate,
+  Comment,
+  CommentCreate,
+  CommentUpdate,
+  Like,
+  LikeCreate,
+  ApiError,
+} from "./types";
+
+const BASE_URL = import.meta.env.VITE_API_BASE_URL || "http://localhost:8000";
+
+const handleResponse = async <T>(res: Response): Promise<T> => {
+  if (!res.ok) {
+    let error: ApiError = { code: res.status, message: res.statusText };
+    try {
+      error = await res.json();
+    } catch (e) {
+      // ignore JSON parse error, use default error
+    }
+    throw error;
+  }
+  return res.json();
+};
+
+// Posts
+export const getPosts = async (): Promise<Post[]> => {
+  const res = await fetch(`${BASE_URL}/posts`);
+  return handleResponse<Post[]>(res);
+};
+
+export const getPost = async (postId: string): Promise<Post> => {
+  const res = await fetch(`${BASE_URL}/posts/${postId}`);
+  return handleResponse<Post>(res);
+};
+
+export const createPost = async (data: PostCreate): Promise<Post> => {
+  const res = await fetch(`${BASE_URL}/posts`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(data),
+  });
+  return handleResponse<Post>(res);
+};
+
+export const updatePost = async (postId: string, data: PostUpdate): Promise<Post> => {
+  const res = await fetch(`${BASE_URL}/posts/${postId}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(data),
+  });
+  return handleResponse<Post>(res);
+};
+
+export const deletePost = async (postId: string): Promise<void> => {
+  const res = await fetch(`${BASE_URL}/posts/${postId}`, { method: "DELETE" });
+  if (!res.ok && res.status !== 204) throw await res.json();
+};
+
+// Comments
+export const getComments = async (postId: string): Promise<Comment[]> => {
+  const res = await fetch(`${BASE_URL}/posts/${postId}/comments`);
+  return handleResponse<Comment[]>(res);
+};
+
+export const getComment = async (postId: string, commentId: string): Promise<Comment> => {
+  const res = await fetch(`${BASE_URL}/posts/${postId}/comments/${commentId}`);
+  return handleResponse<Comment>(res);
+};
+
+export const createComment = async (postId: string, data: CommentCreate): Promise<Comment> => {
+  const res = await fetch(`${BASE_URL}/posts/${postId}/comments`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(data),
+  });
+  return handleResponse<Comment>(res);
+};
+
+export const updateComment = async (
+  postId: string,
+  commentId: string,
+  data: CommentUpdate
+): Promise<Comment> => {
+  const res = await fetch(`${BASE_URL}/posts/${postId}/comments/${commentId}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(data),
+  });
+  return handleResponse<Comment>(res);
+};
+
+export const deleteComment = async (postId: string, commentId: string): Promise<void> => {
+  const res = await fetch(`${BASE_URL}/posts/${postId}/comments/${commentId}`, { method: "DELETE" });
+  if (!res.ok && res.status !== 204) throw await res.json();
+};
+
+// Likes
+export const likePost = async (postId: string, data: LikeCreate): Promise<Like> => {
+  const res = await fetch(`${BASE_URL}/posts/${postId}/likes`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(data),
+  });
+  return handleResponse<Like>(res);
+};
+
+export const unlikePost = async (postId: string): Promise<void> => {
+  const res = await fetch(`${BASE_URL}/posts/${postId}/likes`, { method: "DELETE" });
+  if (!res.ok && res.status !== 204) throw await res.json();
+};
diff --git a/javascript/src/api/types.ts b/javascript/src/api/types.ts
new file mode 100644
index 0000000..b7e69af
--- /dev/null
+++ b/javascript/src/api/types.ts
@@ -0,0 +1,55 @@
+// Types generated from openapi.yaml
+
+export type Post = {
+  id: string;
+  username: string;
+  content: string;
+  createdAt: string;
+  updatedAt: string;
+  comments: Comment[];
+  likes: number;
+};
+
+export type PostCreate = {
+  username: string;
+  content: string;
+};
+
+export type PostUpdate = {
+  username: string;
+  content: string;
+};
+
+export type Comment = {
+  id: string;
+  postId: string;
+  username: string;
+  content: string;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type CommentCreate = {
+  username: string;
+  content: string;
+};
+
+export type CommentUpdate = {
+  username: string;
+  content: string;
+};
+
+export type Like = {
+  postId: string;
+  username: string;
+  createdAt: string;
+};
+
+export type LikeCreate = {
+  username: string;
+};
+
+export type ApiError = {
+  code: number;
+  message: string;
+};
diff --git a/javascript/src/components/CommentCard.tsx b/javascript/src/components/CommentCard.tsx
new file mode 100644
index 0000000..5c367bd
--- /dev/null
+++ b/javascript/src/components/CommentCard.tsx
@@ -0,0 +1,20 @@
+import React from "react";
+import type { Comment } from "../api/types";
+
+type CommentCardProps = {
+  comment: Comment;
+};
+
+const CommentCard: React.FC<CommentCardProps> = ({ comment }) => {
+  return (
+    <div className="bg-gray-100 rounded p-2" tabIndex={0} aria-label="Comment">
+      <div className="flex items-center gap-2">
+        <span className="font-semibold">{comment.username}</span>
+        <span className="text-xs text-gray-400">{new Date(comment.createdAt).toLocaleString()}</span>
+      </div>
+      <div className="text-gray-800 text-sm">{comment.content}</div>
+    </div>
+  );
+};
+
+export default CommentCard;
diff --git a/javascript/src/components/CommentForm.tsx b/javascript/src/components/CommentForm.tsx
new file mode 100644
index 0000000..25dfcd0
--- /dev/null
+++ b/javascript/src/components/CommentForm.tsx
@@ -0,0 +1,71 @@
+import React, { useState } from "react";
+import { createComment } from "../api/client";
+import type { CommentCreate, ApiError } from "../api/types";
+
+type CommentFormProps = {
+  postId: string;
+  onCommentAdded?: () => void;
+};
+
+const CommentForm: React.FC<CommentFormProps> = ({ postId, onCommentAdded }) => {
+  const [username, setUsername] = useState("");
+  const [content, setContent] = useState("");
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setError(null);
+    if (!username.trim() || !content.trim()) {
+      setError("Username and content are required.");
+      return;
+    }
+    setLoading(true);
+    try {
+      const data: CommentCreate = { username, content };
+      await createComment(postId, data);
+      setUsername("");
+      setContent("");
+      if (onCommentAdded) onCommentAdded();
+    } catch (err) {
+      const apiError = err as ApiError;
+      setError(apiError.message || "Failed to add comment");
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <form className="bg-gray-50 rounded-lg p-2 flex flex-col gap-2" aria-label="Comment Form" onSubmit={handleSubmit}>
+      <input
+        className="border rounded px-2 py-1"
+        type="text"
+        placeholder="Your name"
+        value={username}
+        onChange={e => setUsername(e.target.value)}
+        aria-label="Username"
+        required
+      />
+      <textarea
+        className="border rounded px-2 py-1"
+        placeholder="Add a comment..."
+        value={content}
+        onChange={e => setContent(e.target.value)}
+        aria-label="Comment content"
+        required
+        rows={2}
+      />
+      <button
+        type="submit"
+        className="bg-blue-600 text-white rounded px-3 py-1 disabled:opacity-50"
+        disabled={loading}
+        aria-label="Submit comment"
+      >
+        {loading ? "Posting..." : "Post Comment"}
+      </button>
+      {error && <div className="text-red-500 text-xs">{error}</div>}
+    </form>
+  );
+};
+
+export default CommentForm;
diff --git a/javascript/src/components/CommentList.tsx b/javascript/src/components/CommentList.tsx
new file mode 100644
index 0000000..2801f1d
--- /dev/null
+++ b/javascript/src/components/CommentList.tsx
@@ -0,0 +1,46 @@
+import React, { useEffect, useState } from "react";
+import type { Comment, ApiError } from "../api/types";
+import { getComments } from "../api/client";
+import CommentCard from "./CommentCard";
+import Loader from "./Loader";
+
+type CommentListProps = {
+  postId: string;
+};
+
+const CommentList: React.FC<CommentListProps> = ({ postId }) => {
+  const [comments, setComments] = useState<Comment[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    const fetchComments = async () => {
+      setLoading(true);
+      setError(null);
+      try {
+        const data = await getComments(postId);
+        setComments(data);
+      } catch (err) {
+        const apiError = err as ApiError;
+        setError(apiError.message || "API unavailable");
+      } finally {
+        setLoading(false);
+      }
+    };
+    fetchComments();
+  }, [postId]);
+
+  if (loading) return <Loader />;
+  if (error) return <div className="text-red-500 text-xs">{error}</div>;
+  if (!comments.length) return <div className="text-gray-400 text-sm">No comments yet.</div>;
+
+  return (
+    <section className="flex flex-col gap-2" aria-label="Comments List">
+      {comments.map((comment) => (
+        <CommentCard key={comment.id} comment={comment} />
+      ))}
+    </section>
+  );
+};
+
+export default CommentList;
diff --git a/javascript/src/components/ErrorBanner.tsx b/javascript/src/components/ErrorBanner.tsx
new file mode 100644
index 0000000..27a566e
--- /dev/null
+++ b/javascript/src/components/ErrorBanner.tsx
@@ -0,0 +1,13 @@
+import React from "react";
+
+type ErrorBannerProps = {
+  message: string;
+};
+
+const ErrorBanner: React.FC<ErrorBannerProps> = ({ message }) => (
+  <div className="w-full bg-red-600 text-white text-center py-2" role="alert" tabIndex={0} aria-label="API Error">
+    {message}
+  </div>
+);
+
+export default ErrorBanner;
diff --git a/javascript/src/components/LikeButton.tsx b/javascript/src/components/LikeButton.tsx
new file mode 100644
index 0000000..69fc780
--- /dev/null
+++ b/javascript/src/components/LikeButton.tsx
@@ -0,0 +1,25 @@
+import React from "react";
+
+type LikeButtonProps = {
+  liked: boolean;
+  onClick: () => void;
+};
+
+const LikeButton: React.FC<LikeButtonProps> = ({ liked, onClick }) => {
+  return (
+    <button
+      type="button"
+      className="flex items-center gap-1 px-2 py-1 rounded focus:outline-none focus:ring-2 focus:ring-blue-500"
+      aria-pressed={liked}
+      aria-label={liked ? "Unlike post" : "Like post"}
+      tabIndex={0}
+      onClick={onClick}
+      onKeyDown={e => { if (e.key === 'Enter' || e.key === ' ') onClick(); }}
+    >
+      <span className={liked ? "text-blue-600" : "text-gray-400"}>♥</span>
+      <span>{liked ? "Liked" : "Like"}</span>
+    </button>
+  );
+};
+
+export default LikeButton;
diff --git a/javascript/src/components/Loader.tsx b/javascript/src/components/Loader.tsx
new file mode 100644
index 0000000..6bfe81c
--- /dev/null
+++ b/javascript/src/components/Loader.tsx
@@ -0,0 +1,9 @@
+import React from "react";
+
+const Loader: React.FC = () => (
+  <div className="flex justify-center items-center py-8" aria-label="Loading">
+    <div className="animate-spin rounded-full h-8 w-8 border-t-2 border-b-2 border-blue-500"></div>
+  </div>
+);
+
+export default Loader;
diff --git a/javascript/src/components/PostCard.tsx b/javascript/src/components/PostCard.tsx
new file mode 100644
index 0000000..b2cd62b
--- /dev/null
+++ b/javascript/src/components/PostCard.tsx
@@ -0,0 +1,65 @@
+import React, { useState } from "react";
+import type { Post } from "../api/types";
+import LikeButton from "./LikeButton";
+import CommentList from "./CommentList";
+import CommentForm from "./CommentForm";
+import { likePost, unlikePost } from "../api/client";
+
+type PostCardProps = {
+  post: Post;
+};
+
+const PostCard: React.FC<PostCardProps> = ({ post }) => {
+  // For demo, assume username is 'demo-user'. In real app, get from auth/user context.
+  const username = "demo-user";
+  const [liked, setLiked] = useState(false);
+  const [likeCount, setLikeCount] = useState(post.likes);
+  const [likeError, setLikeError] = useState<string | null>(null);
+  const [commentsKey, setCommentsKey] = useState(0); // for refreshing CommentList
+  const handleLike = async () => {
+    setLikeError(null);
+    if (!liked) {
+      setLiked(true);
+      setLikeCount((c) => c + 1);
+      try {
+        await likePost(post.id, { username });
+      } catch (err) {
+        setLiked(false);
+        setLikeCount((c) => c - 1);
+        setLikeError("Failed to like post");
+      }
+    } else {
+      setLiked(false);
+      setLikeCount((c) => c - 1);
+      try {
+        await unlikePost(post.id);
+      } catch (err) {
+        setLiked(true);
+        setLikeCount((c) => c + 1);
+        setLikeError("Failed to unlike post");
+      }
+    }
+  };
+  return (
+    <article className="bg-white rounded-lg shadow p-4 flex flex-col gap-2" tabIndex={0} aria-label="Post">
+      <div className="flex items-center gap-2">
+        <span className="font-semibold">{post.username}</span>
+        <span className="text-xs text-gray-400">{new Date(post.createdAt).toLocaleString()}</span>
+      </div>
+      <div className="text-base text-gray-800">{post.content}</div>
+      <div className="flex items-center gap-4 mt-2">
+        <span className="text-sm text-gray-500">{likeCount} Likes</span>
+        <span className="text-sm text-gray-500">{post.comments.length} Comments</span>
+        <LikeButton liked={liked} onClick={handleLike} />
+      </div>
+      {likeError && <div className="text-red-500 text-xs mt-1">{likeError}</div>}
+      <div className="mt-4">
+        <h3 className="font-semibold text-sm mb-1">Comments</h3>
+        <CommentForm postId={post.id} onCommentAdded={() => setCommentsKey(k => k + 1)} />
+        <CommentList key={commentsKey} postId={post.id} />
+      </div>
+    </article>
+  );
+};
+
+export default PostCard;
diff --git a/javascript/src/components/PostForm.tsx b/javascript/src/components/PostForm.tsx
new file mode 100644
index 0000000..2abea30
--- /dev/null
+++ b/javascript/src/components/PostForm.tsx
@@ -0,0 +1,70 @@
+import React, { useState } from "react";
+import { createPost } from "../api/client";
+import type { PostCreate, ApiError } from "../api/types";
+
+type PostFormProps = {
+  onPostCreated?: () => void;
+};
+
+const PostForm: React.FC<PostFormProps> = ({ onPostCreated }) => {
+  const [username, setUsername] = useState("");
+  const [content, setContent] = useState("");
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setError(null);
+    if (!username.trim() || !content.trim()) {
+      setError("Username and content are required.");
+      return;
+    }
+    setLoading(true);
+    try {
+      const data: PostCreate = { username, content };
+      await createPost(data);
+      setUsername("");
+      setContent("");
+      if (onPostCreated) onPostCreated();
+    } catch (err) {
+      const apiError = err as ApiError;
+      setError(apiError.message || "Failed to create post");
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return (
+    <form className="bg-gray-50 rounded-lg p-4 flex flex-col gap-2" aria-label="Post Form" onSubmit={handleSubmit}>
+      <input
+        className="border rounded px-2 py-1"
+        type="text"
+        placeholder="Your name"
+        value={username}
+        onChange={e => setUsername(e.target.value)}
+        aria-label="Username"
+        required
+      />
+      <textarea
+        className="border rounded px-2 py-1"
+        placeholder="What's on your mind?"
+        value={content}
+        onChange={e => setContent(e.target.value)}
+        aria-label="Post content"
+        required
+        rows={3}
+      />
+      <button
+        type="submit"
+        className="bg-blue-600 text-white rounded px-3 py-1 disabled:opacity-50"
+        disabled={loading}
+        aria-label="Submit post"
+      >
+        {loading ? "Posting..." : "Post"}
+      </button>
+      {error && <div className="text-red-500 text-xs">{error}</div>}
+    </form>
+  );
+};
+
+export default PostForm;
diff --git a/javascript/src/components/PostList.tsx b/javascript/src/components/PostList.tsx
new file mode 100644
index 0000000..4c83e4b
--- /dev/null
+++ b/javascript/src/components/PostList.tsx
@@ -0,0 +1,22 @@
+import React from "react";
+import type { Post } from "../api/types";
+import PostCard from "./PostCard";
+
+type PostListProps = {
+  posts: Post[];
+};
+
+const PostList: React.FC<PostListProps> = ({ posts }) => {
+  if (!posts.length) {
+    return <div className="text-center text-gray-500">No posts yet.</div>;
+  }
+  return (
+    <section className="w-full max-w-2xl mx-auto flex flex-col gap-4" aria-label="Posts List">
+      {posts.map((post) => (
+        <PostCard key={post.id} post={post} />
+      ))}
+    </section>
+  );
+};
+
+export default PostList;
diff --git a/javascript/src/index.css b/javascript/src/index.css
new file mode 100644
index 0000000..e69de29
diff --git a/javascript/tailwind.config.js b/javascript/tailwind.config.js
new file mode 100644
index 0000000..e69de29
diff --git a/javascript/vite.config.ts b/javascript/vite.config.ts
new file mode 100644
index 0000000..e69de29
diff --git a/openapi.yaml b/openapi.yaml
new file mode 100644
index 0000000..ff45c72
--- /dev/null
+++ b/openapi.yaml
@@ -0,0 +1,381 @@
+openapi: 3.0.1
+info:
+  title: Simple Social Media Application API
+  version: 1.0.0
+  description: |
+    API for a basic Social Networking Service (SNS) that allows users to create, retrieve, update, and delete posts; add comments; and like/unlike posts. Designed for educational and MVP use cases.
+servers:
+  - url: http://localhost:8080/api
+paths:
+  /posts:
+    get:
+      summary: List all posts
+      description: Retrieve a list of all recent posts.
+      responses:
+        '200':
+          description: A list of posts
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: '#/components/schemas/Post'
+        '500':
+          $ref: '#/components/responses/InternalServerError'
+    post:
+      summary: Create a new post
+      description: Create a new post with username and content.
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/PostCreateRequest'
+      responses:
+        '201':
+          description: Post created
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Post'
+        '400':
+          $ref: '#/components/responses/BadRequest'
+        '500':
+          $ref: '#/components/responses/InternalServerError'
+  /posts/{postId}:
+    get:
+      summary: Get a single post
+      description: Retrieve a specific post by ID.
+      parameters:
+        - $ref: '#/components/parameters/PostId'
+      responses:
+        '200':
+          description: The requested post
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Post'
+        '404':
+          $ref: '#/components/responses/NotFound'
+        '500':
+          $ref: '#/components/responses/InternalServerError'
+    patch:
+      summary: Update a post
+      description: Update an existing post's content and username.
+      parameters:
+        - $ref: '#/components/parameters/PostId'
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/PostUpdateRequest'
+      responses:
+        '200':
+          description: Post updated
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Post'
+        '400':
+          $ref: '#/components/responses/BadRequest'
+        '404':
+          $ref: '#/components/responses/NotFound'
+        '500':
+          $ref: '#/components/responses/InternalServerError'
+    delete:
+      summary: Delete a post
+      description: Delete a post by ID.
+      parameters:
+        - $ref: '#/components/parameters/PostId'
+      responses:
+        '204':
+          description: Post deleted
+        '404':
+          $ref: '#/components/responses/NotFound'
+        '500':
+          $ref: '#/components/responses/InternalServerError'
+  /posts/{postId}/comments:
+    get:
+      summary: List comments for a post
+      description: Retrieve all comments for a specific post.
+      parameters:
+        - $ref: '#/components/parameters/PostId'
+      responses:
+        '200':
+          description: A list of comments
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: '#/components/schemas/Comment'
+        '404':
+          $ref: '#/components/responses/NotFound'
+        '500':
+          $ref: '#/components/responses/InternalServerError'
+    post:
+      summary: Create a comment
+      description: Add a comment to a post.
+      parameters:
+        - $ref: '#/components/parameters/PostId'
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/CommentCreateRequest'
+      responses:
+        '201':
+          description: Comment created
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Comment'
+        '400':
+          $ref: '#/components/responses/BadRequest'
+        '404':
+          $ref: '#/components/responses/NotFound'
+        '500':
+          $ref: '#/components/responses/InternalServerError'
+  /posts/{postId}/comments/{commentId}:
+    get:
+      summary: Get a specific comment
+      description: Retrieve a specific comment by ID for a post.
+      parameters:
+        - $ref: '#/components/parameters/PostId'
+        - $ref: '#/components/parameters/CommentId'
+      responses:
+        '200':
+          description: The requested comment
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Comment'
+        '404':
+          $ref: '#/components/responses/NotFound'
+        '500':
+          $ref: '#/components/responses/InternalServerError'
+    patch:
+      summary: Update a comment
+      description: Update an existing comment's content and username.
+      parameters:
+        - $ref: '#/components/parameters/PostId'
+        - $ref: '#/components/parameters/CommentId'
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/CommentUpdateRequest'
+      responses:
+        '200':
+          description: Comment updated
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Comment'
+        '400':
+          $ref: '#/components/responses/BadRequest'
+        '404':
+          $ref: '#/components/responses/NotFound'
+        '500':
+          $ref: '#/components/responses/InternalServerError'
+    delete:
+      summary: Delete a comment
+      description: Delete a comment by ID for a post.
+      parameters:
+        - $ref: '#/components/parameters/PostId'
+        - $ref: '#/components/parameters/CommentId'
+      responses:
+        '204':
+          description: Comment deleted
+        '404':
+          $ref: '#/components/responses/NotFound'
+        '500':
+          $ref: '#/components/responses/InternalServerError'
+  /posts/{postId}/likes:
+    post:
+      summary: Like a post
+      description: Like a post by providing a username.
+      parameters:
+        - $ref: '#/components/parameters/PostId'
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/LikeRequest'
+      responses:
+        '201':
+          description: Post liked
+        '400':
+          $ref: '#/components/responses/BadRequest'
+        '404':
+          $ref: '#/components/responses/NotFound'
+        '500':
+          $ref: '#/components/responses/InternalServerError'
+    delete:
+      summary: Unlike a post
+      description: Remove a like from a post by the current user.
+      parameters:
+        - $ref: '#/components/parameters/PostId'
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/LikeRequest'
+      responses:
+        '204':
+          description: Like removed
+        '404':
+          $ref: '#/components/responses/NotFound'
+        '500':
+          $ref: '#/components/responses/InternalServerError'
+components:
+  parameters:
+    PostId:
+      name: postId
+      in: path
+      required: true
+      description: The ID of the post
+      schema:
+        type: string
+    CommentId:
+      name: commentId
+      in: path
+      required: true
+      description: The ID of the comment
+      schema:
+        type: string
+  responses:
+    BadRequest:
+      description: Bad request
+      content:
+        application/json:
+          schema:
+            $ref: '#/components/schemas/Error'
+    NotFound:
+      description: Resource not found
+      content:
+        application/json:
+          schema:
+            $ref: '#/components/schemas/Error'
+    InternalServerError:
+      description: Internal server error
+      content:
+        application/json:
+          schema:
+            $ref: '#/components/schemas/Error'
+  schemas:
+    Post:
+      type: object
+      properties:
+        id:
+          type: string
+        username:
+          type: string
+        content:
+          type: string
+        createdAt:
+          type: string
+          format: date-time
+        updatedAt:
+          type: string
+          format: date-time
+        comments:
+          type: array
+          items:
+            $ref: '#/components/schemas/Comment'
+        likes:
+          type: integer
+          description: Number of likes
+      required:
+        - id
+        - username
+        - content
+        - createdAt
+        - updatedAt
+        - likes
+    PostCreateRequest:
+      type: object
+      properties:
+        username:
+          type: string
+        content:
+          type: string
+      required:
+        - username
+        - content
+    PostUpdateRequest:
+      type: object
+      properties:
+        username:
+          type: string
+        content:
+          type: string
+      required:
+        - username
+        - content
+    Comment:
+      type: object
+      properties:
+        id:
+          type: string
+        postId:
+          type: string
+        username:
+          type: string
+        content:
+          type: string
+        createdAt:
+          type: string
+          format: date-time
+        updatedAt:
+          type: string
+          format: date-time
+      required:
+        - id
+        - postId
+        - username
+        - content
+        - createdAt
+        - updatedAt
+    CommentCreateRequest:
+      type: object
+      properties:
+        username:
+          type: string
+        content:
+          type: string
+      required:
+        - username
+        - content
+    CommentUpdateRequest:
+      type: object
+      properties:
+        username:
+          type: string
+        content:
+          type: string
+      required:
+        - username
+        - content
+    LikeRequest:
+      type: object
+      properties:
+        username:
+          type: string
+      required:
+        - username
+    Error:
+      type: object
+      properties:
+        message:
+          type: string
+        code:
+          type: integer
+      required:
+        - message
+        - code
diff --git a/python/main.py b/python/main.py
new file mode 100644
index 0000000..e0eed74
--- /dev/null
+++ b/python/main.py
@@ -0,0 +1,359 @@
+# FastAPI SNS API implementation matching openapi.yaml
+import os
+import yaml
+from fastapi import FastAPI, HTTPException, Request, Response, status, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, FileResponse
+from fastapi.openapi.docs import get_swagger_ui_html
+from pydantic import BaseModel, Field
+from typing import List, Optional
+import sqlite3
+from datetime import datetime
+
+DB_PATH = os.path.join(os.path.dirname(__file__), 'sns_api.db')
+OPENAPI_PATH = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'openapi.yaml')
+
+def get_db():
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    try:
+        yield conn
+    finally:
+        conn.close()
+
+def init_db():
+    conn = sqlite3.connect(DB_PATH)
+    c = conn.cursor()
+    # Posts table
+    c.execute('''CREATE TABLE IF NOT EXISTS posts (
+        id TEXT PRIMARY KEY,
+        username TEXT NOT NULL,
+        content TEXT NOT NULL,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL
+    )''')
+    # Comments table
+    c.execute('''CREATE TABLE IF NOT EXISTS comments (
+        id TEXT PRIMARY KEY,
+        postId TEXT NOT NULL,
+        username TEXT NOT NULL,
+        content TEXT NOT NULL,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL,
+        FOREIGN KEY(postId) REFERENCES posts(id) ON DELETE CASCADE
+    )''')
+    # Likes table
+    c.execute('''CREATE TABLE IF NOT EXISTS likes (
+        postId TEXT NOT NULL,
+        username TEXT NOT NULL,
+        PRIMARY KEY(postId, username),
+        FOREIGN KEY(postId) REFERENCES posts(id) ON DELETE CASCADE
+    )''')
+    conn.commit()
+    conn.close()
+
+app = FastAPI(docs_url="/docs", redoc_url=None, openapi_url=None)
+
+# Enable CORS from everywhere
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.on_event("startup")
+def on_startup():
+    init_db()
+
+# --- Pydantic Models (matching openapi.yaml) ---
+class Error(BaseModel):
+    message: str
+    code: int
+
+class Comment(BaseModel):
+    id: str
+    postId: str
+    username: str
+    content: str
+    createdAt: str
+    updatedAt: str
+
+class CommentCreateRequest(BaseModel):
+    username: str
+    content: str
+
+class CommentUpdateRequest(BaseModel):
+    username: str
+    content: str
+
+class Post(BaseModel):
+    id: str
+    username: str
+    content: str
+    createdAt: str
+    updatedAt: str
+    comments: List[Comment] = []
+    likes: int
+
+class PostCreateRequest(BaseModel):
+    username: str
+    content: str
+
+class PostUpdateRequest(BaseModel):
+    username: str
+    content: str
+
+class LikeRequest(BaseModel):
+    username: str
+
+# --- Utility Functions ---
+import uuid
+def now_iso() -> str:
+    return datetime.utcnow().isoformat() + 'Z'
+
+def get_post_by_id(conn, post_id: str):
+    post = conn.execute("SELECT * FROM posts WHERE id = ?", (post_id,)).fetchone()
+    return post
+
+def get_comments_by_post(conn, post_id: str):
+    rows = conn.execute("SELECT * FROM comments WHERE postId = ? ORDER BY createdAt ASC", (post_id,)).fetchall()
+    return [dict(row) for row in rows]
+
+def get_likes_count(conn, post_id: str) -> int:
+    row = conn.execute("SELECT COUNT(*) as cnt FROM likes WHERE postId = ?", (post_id,)).fetchone()
+    return row["cnt"] if row else 0
+
+def get_comment_by_id(conn, post_id: str, comment_id: str):
+    comment = conn.execute("SELECT * FROM comments WHERE id = ? AND postId = ?", (comment_id, post_id)).fetchone()
+    return comment
+
+# --- API Endpoints ---
+# /posts GET
+@app.get("/posts", response_model=List[Post], responses={500: {"model": Error}})
+def list_posts(db=Depends(get_db)):
+    try:
+        posts = db.execute("SELECT * FROM posts ORDER BY createdAt DESC").fetchall()
+        result = []
+        for post in posts:
+            post_id = post["id"]
+            comments = [Comment(**c) for c in get_comments_by_post(db, post_id)]
+            likes = get_likes_count(db, post_id)
+            result.append(Post(
+                id=post["id"],
+                username=post["username"],
+                content=post["content"],
+                createdAt=post["createdAt"],
+                updatedAt=post["updatedAt"],
+                comments=comments,
+                likes=likes
+            ))
+        return result
+    except Exception as e:
+        return JSONResponse(status_code=500, content=Error(message="Internal server error", code=500).dict())
+
+# /posts POST
+@app.post("/posts", response_model=Post, status_code=201, responses={400: {"model": Error}, 500: {"model": Error}})
+def create_post(body: PostCreateRequest, db=Depends(get_db)):
+    if not body.username or not body.content:
+        return JSONResponse(status_code=400, content=Error(message="username and content required", code=400).dict())
+    post_id = str(uuid.uuid4())
+    now = now_iso()
+    try:
+        db.execute("INSERT INTO posts (id, username, content, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?)",
+                   (post_id, body.username, body.content, now, now))
+        db.commit()
+        return Post(
+            id=post_id,
+            username=body.username,
+            content=body.content,
+            createdAt=now,
+            updatedAt=now,
+            comments=[],
+            likes=0
+        )
+    except Exception as e:
+        return JSONResponse(status_code=500, content=Error(message="Internal server error", code=500).dict())
+
+# /posts/{postId} GET
+@app.get("/posts/{postId}", response_model=Post, responses={404: {"model": Error}, 500: {"model": Error}})
+def get_post(postId: str, db=Depends(get_db)):
+    post = get_post_by_id(db, postId)
+    if not post:
+        return JSONResponse(status_code=404, content=Error(message="Post not found", code=404).dict())
+    comments = [Comment(**c) for c in get_comments_by_post(db, postId)]
+    likes = get_likes_count(db, postId)
+    return Post(
+        id=post["id"],
+        username=post["username"],
+        content=post["content"],
+        createdAt=post["createdAt"],
+        updatedAt=post["updatedAt"],
+        comments=comments,
+        likes=likes
+    )
+
+# /posts/{postId} PATCH
+@app.patch("/posts/{postId}", response_model=Post, responses={400: {"model": Error}, 404: {"model": Error}, 500: {"model": Error}})
+def update_post(postId: str, body: PostUpdateRequest, db=Depends(get_db)):
+    post = get_post_by_id(db, postId)
+    if not post:
+        return JSONResponse(status_code=404, content=Error(message="Post not found", code=404).dict())
+    if not body.username or not body.content:
+        return JSONResponse(status_code=400, content=Error(message="username and content required", code=400).dict())
+    now = now_iso()
+    try:
+        db.execute("UPDATE posts SET username = ?, content = ?, updatedAt = ? WHERE id = ?",
+                   (body.username, body.content, now, postId))
+        db.commit()
+        comments = [Comment(**c) for c in get_comments_by_post(db, postId)]
+        likes = get_likes_count(db, postId)
+        return Post(
+            id=postId,
+            username=body.username,
+            content=body.content,
+            createdAt=post["createdAt"],
+            updatedAt=now,
+            comments=comments,
+            likes=likes
+        )
+    except Exception as e:
+        return JSONResponse(status_code=500, content=Error(message="Internal server error", code=500).dict())
+
+# /posts/{postId} DELETE
+@app.delete("/posts/{postId}", status_code=204, responses={404: {"model": Error}, 500: {"model": Error}})
+def delete_post(postId: str, db=Depends(get_db)):
+    post = get_post_by_id(db, postId)
+    if not post:
+        return JSONResponse(status_code=404, content=Error(message="Post not found", code=404).dict())
+    try:
+        db.execute("DELETE FROM posts WHERE id = ?", (postId,))
+        db.commit()
+        return Response(status_code=204)
+    except Exception as e:
+        return JSONResponse(status_code=500, content=Error(message="Internal server error", code=500).dict())
+
+# /posts/{postId}/comments GET
+@app.get("/posts/{postId}/comments", response_model=List[Comment], responses={404: {"model": Error}, 500: {"model": Error}})
+def list_comments(postId: str, db=Depends(get_db)):
+    post = get_post_by_id(db, postId)
+    if not post:
+        return JSONResponse(status_code=404, content=Error(message="Post not found", code=404).dict())
+    try:
+        comments = [Comment(**c) for c in get_comments_by_post(db, postId)]
+        return comments
+    except Exception as e:
+        return JSONResponse(status_code=500, content=Error(message="Internal server error", code=500).dict())
+
+# /posts/{postId}/comments POST
+@app.post("/posts/{postId}/comments", response_model=Comment, status_code=201, responses={400: {"model": Error}, 404: {"model": Error}, 500: {"model": Error}})
+def create_comment(postId: str, body: CommentCreateRequest, db=Depends(get_db)):
+    post = get_post_by_id(db, postId)
+    if not post:
+        return JSONResponse(status_code=404, content=Error(message="Post not found", code=404).dict())
+    if not body.username or not body.content:
+        return JSONResponse(status_code=400, content=Error(message="username and content required", code=400).dict())
+    comment_id = str(uuid.uuid4())
+    now = now_iso()
+    try:
+        db.execute("INSERT INTO comments (id, postId, username, content, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?)",
+                   (comment_id, postId, body.username, body.content, now, now))
+        db.commit()
+        return Comment(
+            id=comment_id,
+            postId=postId,
+            username=body.username,
+            content=body.content,
+            createdAt=now,
+            updatedAt=now
+        )
+    except Exception as e:
+        return JSONResponse(status_code=500, content=Error(message="Internal server error", code=500).dict())
+
+# /posts/{postId}/comments/{commentId} GET
+@app.get("/posts/{postId}/comments/{commentId}", response_model=Comment, responses={404: {"model": Error}, 500: {"model": Error}})
+def get_comment(postId: str, commentId: str, db=Depends(get_db)):
+    comment = get_comment_by_id(db, postId, commentId)
+    if not comment:
+        return JSONResponse(status_code=404, content=Error(message="Comment not found", code=404).dict())
+    return Comment(**comment)
+
+# /posts/{postId}/comments/{commentId} PATCH
+@app.patch("/posts/{postId}/comments/{commentId}", response_model=Comment, responses={400: {"model": Error}, 404: {"model": Error}, 500: {"model": Error}})
+def update_comment(postId: str, commentId: str, body: CommentUpdateRequest, db=Depends(get_db)):
+    comment = get_comment_by_id(db, postId, commentId)
+    if not comment:
+        return JSONResponse(status_code=404, content=Error(message="Comment not found", code=404).dict())
+    if not body.username or not body.content:
+        return JSONResponse(status_code=400, content=Error(message="username and content required", code=400).dict())
+    now = now_iso()
+    try:
+        db.execute("UPDATE comments SET username = ?, content = ?, updatedAt = ? WHERE id = ? AND postId = ?",
+                   (body.username, body.content, now, commentId, postId))
+        db.commit()
+        return Comment(
+            id=commentId,
+            postId=postId,
+            username=body.username,
+            content=body.content,
+            createdAt=comment["createdAt"],
+            updatedAt=now
+        )
+    except Exception as e:
+        return JSONResponse(status_code=500, content=Error(message="Internal server error", code=500).dict())
+
+# /posts/{postId}/comments/{commentId} DELETE
+@app.delete("/posts/{postId}/comments/{commentId}", status_code=204, responses={404: {"model": Error}, 500: {"model": Error}})
+def delete_comment(postId: str, commentId: str, db=Depends(get_db)):
+    comment = get_comment_by_id(db, postId, commentId)
+    if not comment:
+        return JSONResponse(status_code=404, content=Error(message="Comment not found", code=404).dict())
+    try:
+        db.execute("DELETE FROM comments WHERE id = ? AND postId = ?", (commentId, postId))
+        db.commit()
+        return Response(status_code=204)
+    except Exception as e:
+        return JSONResponse(status_code=500, content=Error(message="Internal server error", code=500).dict())
+
+# /posts/{postId}/likes POST
+@app.post("/posts/{postId}/likes", status_code=201, responses={400: {"model": Error}, 404: {"model": Error}, 500: {"model": Error}})
+def like_post(postId: str, body: LikeRequest, db=Depends(get_db)):
+    post = get_post_by_id(db, postId)
+    if not post:
+        return JSONResponse(status_code=404, content=Error(message="Post not found", code=404).dict())
+    if not body.username:
+        return JSONResponse(status_code=400, content=Error(message="username required", code=400).dict())
+    try:
+        db.execute("INSERT OR IGNORE INTO likes (postId, username) VALUES (?, ?)", (postId, body.username))
+        db.commit()
+        return Response(status_code=201)
+    except Exception as e:
+        return JSONResponse(status_code=500, content=Error(message="Internal server error", code=500).dict())
+
+# /posts/{postId}/likes DELETE
+@app.delete("/posts/{postId}/likes", status_code=204, responses={404: {"model": Error}, 500: {"model": Error}})
+def unlike_post(postId: str, body: LikeRequest, db=Depends(get_db)):
+    post = get_post_by_id(db, postId)
+    if not post:
+        return JSONResponse(status_code=404, content=Error(message="Post not found", code=404).dict())
+    if not body.username:
+        return JSONResponse(status_code=400, content=Error(message="username required", code=400).dict())
+    try:
+        db.execute("DELETE FROM likes WHERE postId = ? AND username = ?", (postId, body.username))
+        db.commit()
+        return Response(status_code=204)
+    except Exception as e:
+        return JSONResponse(status_code=500, content=Error(message="Internal server error", code=500).dict())
+
+# Serve openapi.yaml at /openapi.yaml
+@app.get("/openapi.yaml", include_in_schema=False)
+def serve_openapi_yaml():
+    return FileResponse(OPENAPI_PATH, media_type="text/yaml")
+
+# Serve Swagger UI at /docs (default)
+# FastAPI does this by default at /docs
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)