diff --git a/app/app/api/comments/[id]/route.ts b/app/app/api/comments/[id]/route.ts
new file mode 100644
index 0000000..6a922b2
--- /dev/null
+++ b/app/app/api/comments/[id]/route.ts
@@ -0,0 +1,36 @@
+import { NextRequest } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { apiSuccess, apiError } from '@/lib/api-response';
+import { getCurrentUser } from '@/lib/auth';
+
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  try {
+    const currentUser = await getCurrentUser(request);
+    if (!currentUser) return apiError('Unauthorized', 401);
+
+    const { id } = await params;
+
+    const comment = await prisma.comment.findUnique({
+      where: { id }
+    });
+
+    if (!comment) {
+      return apiError('Comment not found', 404);
+    }
+
+    if (comment.userId !== currentUser.id) {
+      return apiError('Forbidden', 403);
+    }
+
+    await prisma.comment.delete({
+      where: { id }
+    });
+
+    return apiSuccess({ success: true });
+  } catch (error) {
+    return apiError('Failed to delete comment', 500);
+  }
+}
diff --git a/app/app/api/posts/[id]/comments/route.ts b/app/app/api/posts/[id]/comments/route.ts
new file mode 100644
index 0000000..6b6e29d
--- /dev/null
+++ b/app/app/api/posts/[id]/comments/route.ts
@@ -0,0 +1,99 @@
+import { NextRequest } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { apiSuccess, apiError } from '@/lib/api-response';
+import { getCurrentUser } from '@/lib/auth';
+import { readJsonBody } from '@/lib/parse-json-body';
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  try {
+    const { id } = await params;
+    const { searchParams } = new URL(request.url);
+    const page = parseInt(searchParams.get('page') || '1');
+    const limit = parseInt(searchParams.get('limit') || '50');
+    const skip = (page - 1) * limit;
+
+    const [comments, total] = await Promise.all([
+      prisma.comment.findMany({
+        where: { postId: id, parentId: null },
+        include: {
+          user: {
+            select: { id: true, name: true, avatarUrl: true, rank: true }
+          },
+          replies: {
+            include: {
+              user: {
+                select: { id: true, name: true, avatarUrl: true, rank: true }
+              }
+            },
+            orderBy: { createdAt: 'asc' }
+          }
+        },
+        orderBy: { createdAt: 'desc' },
+        skip,
+        take: limit,
+      }),
+      prisma.comment.count({
+        where: { postId: id, parentId: null }
+      })
+    ]);
+
+    return apiSuccess({
+      comments,
+      pagination: {
+        page,
+        limit,
+        total,
+        totalPages: Math.ceil(total / limit)
+      }
+    });
+  } catch (error) {
+    return apiError('Failed to fetch comments', 500);
+  }
+}
+
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  try {
+    const currentUser = await getCurrentUser(request);
+    if (!currentUser) return apiError('Unauthorized', 401);
+
+    const { id } = await params;
+    const body = await readJsonBody(request);
+    if (!body.ok) return body.response;
+
+    const { content, parentId, entryId } = body.data as any;
+
+    if (!content || typeof content !== 'string') {
+      return apiError('Content is required', 400);
+    }
+
+    const comment = await prisma.comment.create({
+      data: {
+        content,
+        postId: id,
+        userId: currentUser.id,
+        parentId: parentId || null,
+        entryId: entryId || null,
+      },
+      include: {
+        user: {
+          select: { id: true, name: true, avatarUrl: true, rank: true }
+        },
+        replies: {
+          include: {
+            user: true
+          }
+        }
+      }
+    });
+
+    return apiSuccess(comment);
+  } catch (error) {
+    return apiError('Failed to create comment', 500);
+  }
+}
diff --git a/app/app/api/posts/[id]/contributions/route.ts b/app/app/api/posts/[id]/contributions/route.ts
new file mode 100644
index 0000000..360f84e
--- /dev/null
+++ b/app/app/api/posts/[id]/contributions/route.ts
@@ -0,0 +1,163 @@
+import { NextRequest } from 'next/server';
+import { prisma } from '@/lib/prisma';
+import { apiSuccess, apiError } from '@/lib/api-response';
+import { getCurrentUser } from '@/lib/auth';
+import { readJsonBody } from '@/lib/parse-json-body';
+import { XP_REWARDS, awardXp } from '@/lib/xp';
+import { checkAndAwardBadges } from '@/lib/badges';
+
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  try {
+    const currentUser = await getCurrentUser(request);
+    if (!currentUser) return apiError('Unauthorized', 401);
+
+    const { id: postId } = await params;
+    const body = await readJsonBody<Record<string, unknown>>(request);
+    if (!body.ok) return body.response;
+
+    const { amount, message, isAnonymous } = body.data as any;
+    const parsedAmount = Number(amount);
+
+    if (isNaN(parsedAmount) || parsedAmount <= 0) {
+      return apiError('Amount must be greater than 0', 400);
+    }
+
+    const post = await prisma.post.findUnique({
+      where: { id: postId },
+      select: { id: true, type: true, targetAmount: true, status: true, userId: true },
+    });
+
+    if (!post) {
+      return apiError('Post not found', 404);
+    }
+
+    if (post.type !== 'request') {
+      return apiError('Contributions can only be made to help requests', 400);
+    }
+
+    if (!['open', 'in_progress', 'active'].includes(post.status)) {
+      return apiError('Help request is not accepting contributions', 400);
+    }
+
+    const contribution = await prisma.$transaction(async (tx) => {
+      const created = await tx.helpContribution.create({
+        data: {
+          postId,
+          userId: currentUser.id,
+          amount: parsedAmount,
+          message: message || null,
+          isAnonymous: !!isAnonymous,
+          contributedAt: new Date(),
+        },
+        include: {
+          user: {
+            select: { id: true, name: true, avatarUrl: true, rank: true }
+          }
+        }
+      });
+
+      await awardXp(
+        currentUser.id,
+        XP_REWARDS.contributeToHelpRequest,
+        'help_request_contributed',
+        { metadata: { postId, contributionId: created.id } },
+        tx
+      );
+
+      // Award the creator for receiving a contribution
+      await awardXp(
+        post.userId,
+        XP_REWARDS.receiveContribution,
+        'help_request_received_contribution',
+        { metadata: { postId, contributionId: created.id } },
+        tx
+      );
+
+      // Optional: notification to creator
+      if (post.userId !== currentUser.id && tx.notification?.create) {
+        try {
+          await tx.notification.create({
+            data: {
+              userId: post.userId,
+              type: 'help_contribution',
+              message: `${isAnonymous ? 'Someone' : currentUser.name} contributed to your help request`,
+              link: `/post/${postId}`,
+            }
+          });
+        } catch(e) { /* ignore if table missing */ }
+      }
+
+      return created;
+    });
+
+    // Check badges
+    checkAndAwardBadges(currentUser.id).catch(console.error);
+
+    // Calculate updated progress
+    const aggregate = await prisma.helpContribution.aggregate({
+      where: { postId },
+      _sum: { amount: true }
+    });
+    const totalRaised = aggregate._sum.amount || 0;
+
+    return apiSuccess({
+      contribution,
+      progress: {
+        totalRaised,
+        targetAmount: post.targetAmount,
+        percentage: post.targetAmount ? Math.min(100, Math.round((totalRaised / post.targetAmount) * 100)) : 0
+      }
+    }, 'Contribution successful', 201);
+  } catch (error) {
+    console.error('Contribution error:', error);
+    return apiError('Failed to process contribution', 500);
+  }
+}
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  try {
+    const { id: postId } = await params;
+
+    const post = await prisma.post.findUnique({
+      where: { id: postId },
+      select: { id: true }
+    });
+
+    if (!post) {
+      return apiError('Post not found', 404);
+    }
+
+    const contributions = await prisma.helpContribution.findMany({
+      where: { postId },
+      include: {
+        user: {
+          select: { id: true, name: true, avatarUrl: true, rank: true }
+        }
+      },
+      orderBy: { contributedAt: 'desc' }
+    });
+
+    const aggregate = await prisma.helpContribution.aggregate({
+      where: { postId },
+      _sum: { amount: true }
+    });
+    const totalRaised = aggregate._sum.amount || 0;
+
+    return apiSuccess({
+      contributions: contributions.map(c => ({
+        ...c,
+        user: c.isAnonymous ? { id: 'anonymous', name: 'Anonymous', avatarUrl: null, rank: null } : c.user
+      })),
+      totalRaised
+    });
+  } catch (error) {
+    console.error('Fetch contributions error:', error);
+    return apiError('Failed to fetch contributions', 500);
+  }
+}
diff --git a/app/app/api/posts/[id]/entries/route.ts b/app/app/api/posts/[id]/entries/route.ts
index 027e930..cb9ab49 100644
--- a/app/app/api/posts/[id]/entries/route.ts
+++ b/app/app/api/posts/[id]/entries/route.ts
@@ -5,6 +5,7 @@ import { NextRequest } from 'next/server';
 import { getCurrentUser } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
 import { readJsonBody } from '@/lib/parse-json-body';
+import { checkAndAwardBadges } from '@/lib/badges';
 
 /**
  * POST /api/posts/[id]/entries
@@ -129,6 +130,8 @@ export async function POST (
       return createdEntry;
     });
 
+    checkAndAwardBadges(user.id).catch(console.error);
+
     return apiSuccess(entry, 'Entry created successfully', 201);
   } catch (error) {
     console.error('Error creating entry:', error);
diff --git a/app/app/api/posts/[id]/route.ts b/app/app/api/posts/[id]/route.ts
index f5de40d..f147d6c 100644
--- a/app/app/api/posts/[id]/route.ts
+++ b/app/app/api/posts/[id]/route.ts
@@ -51,6 +51,18 @@ const GET = async (
                         }
                     }
                 },
+                contributions: {
+                    include: {
+                        user: {
+                            select: {
+                                id: true,
+                                name: true,
+                                avatarUrl: true,
+                                username: true,
+                            }
+                        }
+                    }
+                },
             },
         });
 
@@ -58,7 +70,9 @@ const GET = async (
             return apiError('Post not found', 404);
         }
 
-        return apiSuccess(post);
+        const currentAmount = post.contributions?.reduce((sum, c) => sum + c.amount, 0) || 0;
+
+        return apiSuccess({ ...post, currentAmount });
     } catch (error) {
         return apiError('Failed to fetch post', 500);
     }
diff --git a/app/app/api/posts/[id]/select-winners/route.ts b/app/app/api/posts/[id]/select-winners/route.ts
index 7e6b4d2..11e5661 100644
--- a/app/app/api/posts/[id]/select-winners/route.ts
+++ b/app/app/api/posts/[id]/select-winners/route.ts
@@ -3,6 +3,7 @@ import { NextRequest } from "next/server";
 import { getCurrentUser } from "@/lib/auth";
 import { prisma } from "@/lib/prisma";
 import { readJsonBody } from "@/lib/parse-json-body";
+import { checkAndAwardBadges } from "@/lib/badges";
 
 export const POST = async (
     request: NextRequest,
@@ -97,6 +98,10 @@ export const POST = async (
 
         const selectedUsers = selectedEntries.map(e => e.userId);
 
+        for (const winnerId of selectedUsers) {
+             checkAndAwardBadges(winnerId).catch(console.error);
+        }
+
         return apiSuccess({
              message: 'Winners selected successfully',
              winners: selectedUsers
diff --git a/app/app/api/posts/route.ts b/app/app/api/posts/route.ts
index b0d163d..51ba0e4 100644
--- a/app/app/api/posts/route.ts
+++ b/app/app/api/posts/route.ts
@@ -8,6 +8,7 @@ import { getCurrentUser } from "@/lib/auth";
 import { prisma } from "@/lib/prisma";
 import { readJsonBody } from "@/lib/parse-json-body";
 import { POST_SLUG_MAX_LENGTH, sanitizePostSlug } from "@/lib/post-slug";
+import { checkAndAwardBadges } from "@/lib/badges";
 
 const SLUG_SUFFIX_LENGTH = 6;
 
@@ -174,6 +175,8 @@ const POST = async (request: NextRequest) => {
       return createdPost;
     });
 
+    checkAndAwardBadges(user.id).catch(console.error);
+
     return apiSuccess(post, "Post created successfully", 201);
   } catch (error) {
     if (
diff --git a/app/app/api/users/[id]/follow/route.ts b/app/app/api/users/[id]/follow/route.ts
index 5354cb0..09664c0 100644
--- a/app/app/api/users/[id]/follow/route.ts
+++ b/app/app/api/users/[id]/follow/route.ts
@@ -2,6 +2,7 @@ import { NextRequest } from 'next/server';
 import { prisma } from '@/lib/prisma';
 import { apiSuccess, apiError } from '@/lib/api-response';
 import { getCurrentUser } from '@/lib/auth';
+import { checkAndAwardBadges } from '@/lib/badges';
 
 export async function POST(
   request: NextRequest,
@@ -43,6 +44,7 @@ export async function POST(
           followingId: targetUserId,
         }
       });
+      checkAndAwardBadges(targetUserId).catch(console.error);
       return apiSuccess({ success: true, follow }, undefined, 201);
     }
 
diff --git a/app/app/api/users/[id]/route.ts b/app/app/api/users/[id]/route.ts
index e08c383..80cbbfc 100644
--- a/app/app/api/users/[id]/route.ts
+++ b/app/app/api/users/[id]/route.ts
@@ -33,6 +33,9 @@ export async function GET(
               followers: true,
               followings: true,
             }
+          },
+          badges: {
+            include: { badge: true }
           }
         },
       });
@@ -51,7 +54,15 @@ export async function GET(
           isFollowing = !!follow;
         }
 
-        return apiSuccess({ ...user, isFollowing });
+        const normalizedUser = {
+            ...user,
+            badges: (user.badges || []).map((userBadge: any) => ({
+                ...userBadge.badge,
+                awardedAt: userBadge.awardedAt,
+            })),
+        };
+
+        return apiSuccess({ ...normalizedUser, isFollowing });
       }
     } catch (dbError) {
       // Database error - fallback already handled above
diff --git a/app/components/comments-section.tsx b/app/components/comments-section.tsx
index 39e7a34..97130d8 100644
--- a/app/components/comments-section.tsx
+++ b/app/components/comments-section.tsx
@@ -1,25 +1,15 @@
 'use client';
 
 import { Avatar, AvatarFallback, AvatarImage } from '@/components/ui/avatar';
-import {
-  ExternalLink,
-  Flame,
-  ImageIcon,
-  Send,
-  Trophy,
-  Users,
-} from 'lucide-react';
-import type { Post, Reply } from '@/lib/types';
-
-import { Badge } from '@/components/ui/badge';
+import { Flame, MessageSquare, Send } from 'lucide-react';
+import type { Post, Comment } from '@/lib/types';
 import { Button } from '@/components/ui/button';
 import Link from 'next/link';
-import type React from 'react';
+import React, { useState, useEffect } from 'react';
 import { Textarea } from '@/components/ui/textarea';
 import { UserRankBadge } from '@/components/user-rank-badge';
 import { useAppContext } from '@/contexts/app-context';
 import { useRouter } from 'next/navigation';
-import { useState } from 'react';
 
 interface CommentsSectionProps {
   post: Post;
@@ -28,62 +18,65 @@ interface CommentsSectionProps {
 }
 
 interface ReplyFormProps {
-  parentId: string;
-  parentType: 'entry' | 'contribution';
-  onSubmit: (content: string) => void;
-  onCancel: () => void;
+  parentId?: string;
+  onSubmit: (content: string) => Promise<void>;
+  onCancel?: () => void;
+  placeholder?: string;
 }
 
 function ReplyForm({
   parentId,
-  parentType,
   onSubmit,
   onCancel,
+  placeholder = 'Write a comment...'
 }: ReplyFormProps) {
   const [content, setContent] = useState('');
+  const [isSubmitting, setIsSubmitting] = useState(false);
   const { user } = useAppContext();
 
-  const handleSubmit = (e: React.FormEvent) => {
+  const handleSubmit = async (e: React.FormEvent) => {
     e.preventDefault();
-    if (content.trim()) {
-      onSubmit(content.trim());
-      setContent('');
+    if (content.trim() && !isSubmitting) {
+      setIsSubmitting(true);
+      try {
+        await onSubmit(content.trim());
+        setContent('');
+      } finally {
+        setIsSubmitting(false);
+      }
     }
   };
 
   if (!user) return null;
 
   return (
-    <form onSubmit={handleSubmit} className="mt-3 pl-11">
+    <form onSubmit={handleSubmit} className={parentId ? "mt-3 pl-11" : "mb-6"}>
       <div className="flex gap-2">
-        <Avatar className="w-6 h-6">
-          <AvatarImage
-            src={user.avatarUrl || '/placeholder.svg'}
-            alt={user.name}
-          />
+        <Avatar className="w-8 h-8">
+          <AvatarImage src={user.avatarUrl || '/placeholder.svg'} alt={user.name} />
           <AvatarFallback className="text-xs">
-            {user.name
-              .split(' ')
-              .map((n) => n[0])
-              .join('')}
+            {user.name.split(' ').map((n) => n[0]).join('')}
           </AvatarFallback>
         </Avatar>
         <div className="flex-1">
           <Textarea
             value={content}
             onChange={(e) => setContent(e.target.value)}
-            placeholder="Write a reply..."
+            placeholder={placeholder}
             className="min-h-[60px] text-sm resize-none"
             rows={2}
+            disabled={isSubmitting}
           />
           <div className="flex gap-2 mt-2">
-            <Button type="submit" size="sm" disabled={!content.trim()}>
+            <Button type="submit" size="sm" disabled={!content.trim() || isSubmitting}>
               <Send className="w-3 h-3 mr-1" />
-              Reply
-            </Button>
-            <Button type="button" variant="ghost" size="sm" onClick={onCancel}>
-              Cancel
+              {parentId ? 'Reply' : 'Comment'}
             </Button>
+            {onCancel && (
+              <Button type="button" variant="ghost" size="sm" onClick={onCancel} disabled={isSubmitting}>
+                Cancel
+              </Button>
+            )}
           </div>
         </div>
       </div>
@@ -92,10 +85,11 @@ function ReplyForm({
 }
 
 interface ReplyItemProps {
-  reply: Reply;
+  reply: Comment;
+  onDelete: (id: string) => void;
 }
 
-function ReplyItem({ reply }: ReplyItemProps) {
+function ReplyItem({ reply, onDelete }: ReplyItemProps) {
   const { user } = useAppContext();
   const [isBurned, setIsBurned] = useState(false);
   const router = useRouter();
@@ -111,18 +105,12 @@ function ReplyItem({ reply }: ReplyItemProps) {
   };
 
   return (
-    <div className="flex gap-2 py-2 pl-11">
+    <div className="flex gap-2 py-2 pl-11 group">
       <Link href={`/profile/${reply.user.id}`}>
         <Avatar className="w-6 h-6 cursor-pointer hover:opacity-80 transition-opacity">
-          <AvatarImage
-            src={reply.user.avatarUrl || '/placeholder.svg'}
-            alt={reply.user.name}
-          />
+          <AvatarImage src={reply.user.avatarUrl || '/placeholder.svg'} alt={reply.user.name} />
           <AvatarFallback className="text-xs">
-            {reply.user.name
-              .split(' ')
-              .map((n) => n[0])
-              .join('')}
+            {reply.user.name.split(' ').map((n) => n[0]).join('')}
           </AvatarFallback>
         </Avatar>
       </Link>
@@ -138,6 +126,14 @@ function ReplyItem({ reply }: ReplyItemProps) {
           <span className="text-xs text-gray-500">
             {reply.createdAt.toLocaleDateString()}
           </span>
+          {user?.id === reply.user.id && (
+            <button
+              onClick={() => onDelete(reply.id)}
+              className="text-xs text-red-500 opacity-0 group-hover:opacity-100 transition-opacity ml-auto"
+            >
+              Delete
+            </button>
+          )}
         </div>
         <p className="text-xs text-gray-700 dark:text-gray-300 leading-relaxed">
           {reply.content}
@@ -148,15 +144,11 @@ function ReplyItem({ reply }: ReplyItemProps) {
             size="sm"
             onClick={handleBurn}
             className={`h-5 px-1 text-xs transition-colors ${
-              isBurned
-                ? 'text-red-600 hover:text-red-700'
-                : 'text-gray-500 hover:text-orange-500'
+              isBurned ? 'text-red-600 hover:text-red-700' : 'text-gray-500 hover:text-orange-500'
             }`}
           >
-            <Flame
-              className={`w-3 h-3 mr-1 ${isBurned ? 'fill-current' : ''}`}
-            />
-            {reply.burnCount + (isBurned ? 1 : 0)}
+            <Flame className={`w-3 h-3 mr-1 ${isBurned ? 'fill-current' : ''}`} />
+            {isBurned ? 1 : 0}
           </Button>
         </div>
       </div>
@@ -169,102 +161,123 @@ export function CommentsSection({
   showAll = false,
   maxComments = 3,
 }: CommentsSectionProps) {
-  const { user, addReply } = useAppContext();
-  const [replyingTo, setReplyingTo] = useState<{
-    id: string;
-    type: 'entry' | 'contribution';
-  } | null>(null);
-  const [burnedComments, setBurnedComments] = useState<Set<string>>(new Set());
+  const { user } = useAppContext();
+  const [comments, setComments] = useState<Comment[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [replyingTo, setReplyingTo] = useState<string | null>(null);
   const router = useRouter();
 
-  const allComments = [
-    ...(post.entries || []).map((entry) => ({
-      ...entry,
-      type: 'entry' as const,
-      message: entry.content,
-      createdAt: entry.submittedAt,
-    })),
-    ...(post.contributions || []).map((contribution) => ({
-      ...contribution,
-      type: 'contribution' as const,
-      message: contribution.message || `Contributed $${contribution.amount}`,
-      createdAt: contribution.contributedAt,
-    })),
-  ].sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+  useEffect(() => {
+    const fetchComments = async () => {
+      try {
+        const res = await fetch(`/api/posts/${post.id}/comments?limit=50`);
+        const data = await res.json();
+        if (data.success) {
+          const parsed = data.data.comments.map((c: any) => ({
+            ...c,
+            createdAt: new Date(c.createdAt),
+            replies: c.replies?.map((r: any) => ({ ...r, createdAt: new Date(r.createdAt) })) || []
+          }));
+          setComments(parsed);
+        }
+      } catch (error) {
+        console.error('Failed to fetch comments', error);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    fetchComments();
+  }, [post.id]);
 
-  const displayComments = showAll
-    ? allComments
-    : allComments.slice(0, maxComments);
-
-  const handleReply = (
-    parentId: string,
-    parentType: 'entry' | 'contribution',
-  ) => {
+  const handleSubmitComment = async (content: string, parentId?: string) => {
     if (!user) {
       router.push('/login');
       return;
     }
-    setReplyingTo({ id: parentId, type: parentType });
-  };
 
-  const handleSubmitReply = (content: string) => {
-    if (replyingTo && user) {
-      addReply({
-        content,
-        userId: user.id,
-        parentId: replyingTo.id,
-        parentType: replyingTo.type,
+    try {
+      const res = await fetch(`/api/posts/${post.id}/comments`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ content, parentId }),
       });
-      setReplyingTo(null);
+      const data = await res.json();
+      
+      if (data.success) {
+        const newComment = {
+          ...data.data,
+          createdAt: new Date(data.data.createdAt),
+          replies: []
+        };
+
+        if (parentId) {
+          setComments(prev => prev.map(c => 
+            c.id === parentId 
+              ? { ...c, replies: [...(c.replies || []), newComment] }
+              : c
+          ));
+          setReplyingTo(null);
+        } else {
+          setComments(prev => [newComment, ...prev]);
+        }
+      }
+    } catch (error) {
+      console.error('Failed to post comment', error);
     }
   };
 
-  const handleBurnComment = (commentId: string) => {
-    if (!user) {
-      router.push('/login');
-      return;
-    }
-    if (!burnedComments.has(commentId)) {
-      setBurnedComments((prev) => new Set([...prev, commentId]));
+  const handleDeleteComment = async (commentId: string, parentId?: string) => {
+    if (!confirm('Are you sure you want to delete this comment?')) return;
+    try {
+      const res = await fetch(`/api/comments/${commentId}`, { method: 'DELETE' });
+      if (res.ok) {
+        if (parentId) {
+          setComments(prev => prev.map(c => 
+            c.id === parentId 
+              ? { ...c, replies: (c.replies || []).filter(r => r.id !== commentId) }
+              : c
+          ));
+        } else {
+          setComments(prev => prev.filter(c => c.id !== commentId));
+        }
+      }
+    } catch (error) {
+      console.error('Failed to delete comment', error);
     }
   };
 
+  const displayComments = showAll ? comments : comments.slice(0, maxComments);
+
   return (
-    <div className="space-y-3">
+    <div className="space-y-4">
       {showAll && (
         <div className="flex items-center gap-2 pb-2 border-b border-gray-200 dark:border-gray-700">
-          <Users className="w-4 h-4 text-gray-500" />
+          <MessageSquare className="w-4 h-4 text-gray-500" />
           <span className="text-sm font-medium text-gray-700 dark:text-gray-300">
-            {post.type === 'giveaway' ? 'Entries' : 'Contributions'} (
-            {allComments.length})
+            Comments ({comments.length})
           </span>
         </div>
       )}
 
-      <div className="space-y-3">
-        {displayComments.length === 0 ? (
-          <div className="text-center py-4 text-gray-500 dark:text-gray-400 text-sm">
-            No {post.type === 'giveaway' ? 'entries' : 'contributions'} yet
-          </div>
-        ) : (
-          displayComments.map((comment) => {
-            const isBurned = burnedComments.has(comment.id);
-            const replyCount = comment.replies?.length || 0;
+      {user && <ReplyForm onSubmit={(content) => handleSubmitComment(content)} />}
 
-            return (
-              <div key={comment.id} className="space-y-2">
+      {isLoading ? (
+        <div className="text-center py-4 text-sm text-gray-500">Loading comments...</div>
+      ) : (
+        <div className="space-y-4">
+          {displayComments.length === 0 ? (
+            <div className="text-center py-4 text-gray-500 dark:text-gray-400 text-sm">
+              No comments yet. Be the first to comment!
+            </div>
+          ) : (
+            displayComments.map((comment) => (
+              <div key={comment.id} className="space-y-2 group">
                 <div className="flex gap-3 py-2">
                   <Link href={`/profile/${comment.user.id}`}>
                     <Avatar className="w-8 h-8 cursor-pointer hover:opacity-80 transition-opacity">
-                      <AvatarImage
-                        src={comment.user.avatarUrl || '/placeholder.svg'}
-                        alt={comment.user.name}
-                      />
+                      <AvatarImage src={comment.user.avatarUrl || '/placeholder.svg'} alt={comment.user.name} />
                       <AvatarFallback className="text-xs">
-                        {comment.user.name
-                          .split(' ')
-                          .map((n) => n[0])
-                          .join('')}
+                        {comment.user.name.split(' ').map((n) => n[0]).join('')}
                       </AvatarFallback>
                     </Avatar>
                   </Link>
@@ -276,117 +289,73 @@ export function CommentsSection({
                       >
                         {comment.user.name}
                       </Link>
-                      <UserRankBadge
-                        rank={comment.user.rank}
-                        showLevel={false}
-                      />
-                      {comment.type === 'entry' &&
-                        'isWinner' in comment &&
-                        comment.isWinner && (
-                          <Badge className="bg-yellow-100 text-yellow-800 border-yellow-200 text-xs">
-                            <Trophy className="w-3 h-3 mr-1" />
-                            Winner
-                          </Badge>
-                        )}
+                      <UserRankBadge rank={comment.user.rank} showLevel={false} />
                       <span className="text-xs text-gray-500">
                         {comment.createdAt.toLocaleDateString()}
                       </span>
-                      {comment.type === 'entry' && (
-                        <>
-                          {'proofImage' in comment && comment.proofImage && (
-                            <Button
-                              variant="ghost"
-                              size="sm"
-                              className="h-5 px-1 text-xs text-gray-500 hover:text-gray-700"
-                              onClick={() =>
-                                window.open(comment.proofImage, '_blank')
-                              }
-                            >
-                              <ImageIcon className="w-3 h-3" />
-                            </Button>
-                          )}
-                          {'proofUrl' in comment && comment.proofUrl && (
-                            <Button
-                              variant="ghost"
-                              size="sm"
-                              className="h-5 px-1 text-xs text-gray-500 hover:text-gray-700"
-                              onClick={() =>
-                                window.open(comment.proofUrl, '_blank')
-                              }
-                            >
-                              <ExternalLink className="w-3 h-3" />
-                            </Button>
-                          )}
-                        </>
+                      {user?.id === comment.user.id && (
+                        <button
+                          onClick={() => handleDeleteComment(comment.id)}
+                          className="text-xs text-red-500 opacity-0 group-hover:opacity-100 transition-opacity ml-auto"
+                        >
+                          Delete
+                        </button>
                       )}
                     </div>
                     <p className="text-sm text-gray-700 dark:text-gray-300 leading-relaxed">
-                      {comment.message}
+                      {comment.content}
                     </p>
                     <div className="flex items-center gap-3 mt-2">
                       <Button
                         variant="ghost"
                         size="sm"
-                        onClick={() => handleBurnComment(comment.id)}
-                        className={`h-6 px-2 text-xs transition-colors ${
-                          isBurned
-                            ? 'text-red-600 hover:text-red-700'
-                            : 'text-gray-500 hover:text-orange-500'
-                        }`}
+                        className="h-6 px-2 text-xs text-gray-500 hover:text-orange-500 transition-colors"
                       >
-                        <Flame
-                          className={`w-3 h-3 mr-1 ${
-                            isBurned ? 'fill-current' : ''
-                          }`}
-                        />
-                        {Math.floor(Math.random() * 10) + (isBurned ? 1 : 0)}
+                        <Flame className="w-3 h-3 mr-1" />
+                        0
                       </Button>
                       <Button
                         variant="ghost"
                         size="sm"
-                        onClick={() => handleReply(comment.id, comment.type)}
+                        onClick={() => setReplyingTo(replyingTo === comment.id ? null : comment.id)}
                         className="h-6 px-2 text-xs text-gray-500 hover:text-gray-700 transition-colors"
                       >
-                        Reply {replyCount > 0 && `(${replyCount})`}
+                        Reply {(comment.replies?.length || 0) > 0 && `(${comment.replies?.length})`}
                       </Button>
                     </div>
                   </div>
                 </div>
 
-                {/* Replies */}
                 {comment.replies && comment.replies.length > 0 && (
                   <div className="space-y-1">
                     {comment.replies.map((reply) => (
-                      <ReplyItem key={reply.id} reply={reply} />
+                      <ReplyItem 
+                        key={reply.id} 
+                        reply={reply} 
+                        onDelete={(id) => handleDeleteComment(id, comment.id)} 
+                      />
                     ))}
                   </div>
                 )}
 
-                {/* Reply Form */}
-                {replyingTo?.id === comment.id && (
+                {replyingTo === comment.id && (
                   <ReplyForm
                     parentId={comment.id}
-                    parentType={comment.type}
-                    onSubmit={handleSubmitReply}
+                    onSubmit={(content) => handleSubmitComment(content, comment.id)}
                     onCancel={() => setReplyingTo(null)}
                   />
                 )}
               </div>
-            );
-          })
-        )}
-      </div>
+            ))
+          )}
+        </div>
+      )}
 
-      {!showAll && allComments.length > maxComments && (
+      {!showAll && comments.length > maxComments && (
         <div className="pt-2 border-t border-gray-200 dark:border-gray-700">
           <Link href={`/post/${post.id}`}>
-            <Button
-              variant="ghost"
-              size="sm"
-              className="text-xs text-gray-500 hover:text-gray-700"
-            >
-              View all {allComments.length}{' '}
-              {post.type === 'giveaway' ? 'entries' : 'contributions'}
+            <Button variant="ghost" size="sm" className="text-xs text-gray-500 hover:text-gray-700">
+              View all {comments.length} comments
             </Button>
           </Link>
         </div>
diff --git a/app/components/contribution-form.tsx b/app/components/contribution-form.tsx
index 3498744..d8a9267 100644
--- a/app/components/contribution-form.tsx
+++ b/app/components/contribution-form.tsx
@@ -16,21 +16,23 @@ import type React from "react";
 import { Switch } from "@/components/ui/switch";
 import { Textarea } from "@/components/ui/textarea";
 import { toast } from "sonner";
-import { useAppContext } from "@/contexts/app-context";
 import { useState } from "react";
+import { useRouter } from "next/navigation";
 
 interface ContributionFormProps {
   open: boolean;
   onOpenChange: (open: boolean) => void;
   post: Post;
+  onSuccess?: (progress: { totalRaised: number, targetAmount: number, percentage: number }) => void;
 }
 
 export function ContributionForm({
   open,
   onOpenChange,
   post,
+  onSuccess,
 }: ContributionFormProps) {
-  const { makeContribution } = useAppContext();
+  const router = useRouter();
 
   const [formData, setFormData] = useState({
     amount: "",
@@ -54,18 +56,29 @@ export function ContributionForm({
     setIsSubmitting(true);
 
     try {
-      makeContribution({
-        postId: post.id,
-        userId: "", // Will be set by context
-        amount: Number.parseFloat(formData.amount),
-        message: formData.message || undefined,
-        isAnonymous: formData.isAnonymous,
+      const res = await fetch(`/api/posts/${post.id}/contributions`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          amount: Number.parseFloat(formData.amount),
+          message: formData.message || undefined,
+          isAnonymous: formData.isAnonymous,
+        }),
       });
 
+      const data = await res.json();
+      if (!res.ok) throw new Error(data.message || "Failed to contribute");
+
       toast("Contribution sent!", {
-        description: `You've contributed $${formData.amount} to help ${post.author.name}.`,
+        description: `You've contributed $${formData.amount} to help ${post.author?.name || 'this request'}.`,
       });
 
+      if (onSuccess && data.data?.progress) {
+        onSuccess(data.data.progress);
+      }
+
+      router.refresh();
+
       // Reset form
       setFormData({
         amount: "",
diff --git a/app/contexts/app-context.tsx b/app/contexts/app-context.tsx
index 58d95ed..b20894f 100644
--- a/app/contexts/app-context.tsx
+++ b/app/contexts/app-context.tsx
@@ -51,14 +51,6 @@ type AppAction =
   | { type: 'BURN_REPLY'; payload: string }
   | { type: 'ADD_ENTRY'; payload: Entry }
   | { type: 'ADD_CONTRIBUTION'; payload: HelpContribution }
-  | {
-      type: 'ADD_REPLY';
-      payload: {
-        parentId: string;
-        parentType: 'entry' | 'contribution';
-        reply: Reply;
-      };
-    }
   | { type: 'SET_LOADING'; payload: boolean }
   | { type: 'TOGGLE_THEME' }
   | { type: 'SET_CREATE_MODAL'; payload: boolean }
@@ -106,35 +98,6 @@ function appReducer(state: AppState, action: AppAction): AppState {
         ...state,
         contributions: [...state.contributions, action.payload],
       };
-    case 'ADD_REPLY':
-      if (action.payload.parentType === 'entry') {
-        return {
-          ...state,
-          entries: state.entries.map((entry) =>
-            entry.id === action.payload.parentId
-              ? {
-                  ...entry,
-                  replies: [...(entry.replies || []), action.payload.reply],
-                }
-              : entry,
-          ),
-        };
-      }
-
-      return {
-        ...state,
-        contributions: state.contributions.map((contribution) =>
-          contribution.id === action.payload.parentId
-            ? {
-                ...contribution,
-                replies: [
-                  ...(contribution.replies || []),
-                  action.payload.reply,
-                ],
-              }
-            : contribution,
-        ),
-      };
     case 'SET_LOADING':
       return { ...state, isLoading: action.payload };
     case 'TOGGLE_THEME':
@@ -312,9 +275,6 @@ export function AppProvider({ children }: { children: React.ReactNode }) {
       };
       dispatch({ type: 'ADD_POST', payload: newPost });
     },
-    burnReply: (replyId: string) => {
-      dispatch({ type: 'BURN_REPLY', payload: replyId });
-    },
     updatePost: (postId: string, updates: Partial<Post>) => {
       dispatch({ type: 'UPDATE_POST', payload: { id: postId, updates } });
     },
@@ -342,29 +302,6 @@ export function AppProvider({ children }: { children: React.ReactNode }) {
       };
       dispatch({ type: 'ADD_CONTRIBUTION', payload: newContribution });
     },
-    addReply: (
-      entry: Omit<Reply, 'id' | 'createdAt' | 'user' | 'burnCount'>,
-    ) => {
-      const reply: Reply = {
-        id: Date.now().toString(),
-        parentId: entry.parentId,
-        parentType: entry.parentType,
-        userId: state.user!.id,
-        content: entry.content,
-        user: state.user!,
-        createdAt: new Date(),
-        burnCount: 0,
-      };
-
-      dispatch({
-        type: 'ADD_REPLY',
-        payload: {
-          parentId: entry.parentId,
-          parentType: entry.parentType,
-          reply,
-        },
-      });
-    },
     toggleTheme: () => {
       dispatch({ type: 'TOGGLE_THEME' });
     },
diff --git a/app/lib/badges.ts b/app/lib/badges.ts
new file mode 100644
index 0000000..c4e9a5f
--- /dev/null
+++ b/app/lib/badges.ts
@@ -0,0 +1,99 @@
+import { prisma } from '@/lib/prisma';
+
+export async function checkAndAwardBadges(userId: string) {
+  try {
+    const user = await prisma.user.findUnique({
+      where: { id: userId },
+      include: {
+        _count: {
+          select: {
+            posts: { where: { type: 'giveaway' } },
+            helpContributions: true,
+            followers: true,
+          }
+        },
+        badges: true,
+      }
+    });
+
+    if (!user) return;
+
+    const currentBadgeIds = new Set(user.badges.map(b => b.badgeId));
+    const newlyAwarded: string[] = [];
+
+    // Rule: First Giveaway
+    if (user._count.posts >= 1 && !currentBadgeIds.has('first-giveaway')) {
+      newlyAwarded.push('first-giveaway');
+    }
+
+    // Rule: Generous Heart
+    if (user._count.helpContributions >= 10 && !currentBadgeIds.has('generous-heart')) {
+      newlyAwarded.push('generous-heart');
+    }
+
+    // Rule: Community Builder
+    if (user._count.followers >= 100 && !currentBadgeIds.has('community-builder')) {
+      newlyAwarded.push('community-builder');
+    }
+
+    // Other generic badge checks (e.g. from seed.ts)
+    const activitiesCount = await prisma.activity.count({ where: { userId } });
+    if (activitiesCount >= 1 && !currentBadgeIds.has('first-step')) newlyAwarded.push('first-step');
+    if (activitiesCount >= 5 && !currentBadgeIds.has('generous-giver')) newlyAwarded.push('generous-giver');
+    if (activitiesCount >= 10 && !currentBadgeIds.has('community-hero')) newlyAwarded.push('community-hero');
+
+    for (const badgeId of newlyAwarded) {
+      // Ensure the badge exists in the DB, create on the fly if it's one of the new examples
+      const badgeExists = await prisma.badge.findUnique({ where: { id: badgeId } });
+      
+      if (!badgeExists) {
+        let name = badgeId.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+        let color = 'bg-blue-100 text-blue-800';
+        let tier = 'Bronze';
+        let iconUrl = `https://api.dicebear.com/9.x/icons/svg?seed=${badgeId}`;
+        
+        if (badgeId === 'first-giveaway') {
+           color = 'bg-purple-100 text-purple-800';
+        } else if (badgeId === 'generous-heart') {
+           color = 'bg-pink-100 text-pink-800';
+           tier = 'Silver';
+        } else if (badgeId === 'community-builder') {
+           color = 'bg-green-100 text-green-800';
+           tier = 'Gold';
+        }
+
+        await prisma.badge.create({
+          data: {
+            id: badgeId,
+            name,
+            description: `Awarded for earning the ${name} achievement`,
+            color,
+            tier,
+            iconUrl,
+          }
+        });
+      }
+
+      await prisma.userBadge.upsert({
+        where: { userId_badgeId: { userId, badgeId } },
+        update: {},
+        create: {
+          userId,
+          badgeId,
+        }
+      });
+      
+      // Optionally create a notification here
+      await prisma.notification.create({
+        data: {
+          userId,
+          type: 'badge_awarded',
+          message: `You earned a new badge: ${badgeId.replace('-', ' ')}!`,
+          link: `/profile/${userId}`,
+        }
+      });
+    }
+  } catch (error) {
+    console.error('Error checking and awarding badges:', error);
+  }
+}
diff --git a/app/lib/types.ts b/app/lib/types.ts
index 8bd97ce..14cc4ec 100644
--- a/app/lib/types.ts
+++ b/app/lib/types.ts
@@ -179,8 +179,6 @@ export interface AppContextType extends AppState {
   submitEntry: (entry: Omit<Entry, "id" | "submittedAt" | "user">) => void
   // Contribution actions
   makeContribution: (contribution: Omit<HelpContribution, "id" | "contributedAt" | "user">) => void
-  addReply: (reply: Omit<Reply, "id" | "createdAt" | "user" | "burnCount">) => void
-  burnReply: (replyId: string) => void
   // Theme actions
   toggleTheme: () => void
   setShowCreateModal: (show: boolean) => void