diff --git a/prisma/migrations/20240225042831_create_recurring_transactions/migration.sql b/prisma/migrations/20240225042831_create_recurring_transactions/migration.sql
new file mode 100644
index 00000000..ab57954c
--- /dev/null
+++ b/prisma/migrations/20240225042831_create_recurring_transactions/migration.sql
@@ -0,0 +1,16 @@
+-- CreateTable
+CREATE TABLE "RecurringTransactions" (
+    "groupId" VARCHAR(255) NOT NULL,
+    "expenseId" VARCHAR(255) NOT NULL,
+    "createNextAt" INT NOT NULL,
+    "lockId" VARCHAR(255) DEFAULT NULL,
+
+    CONSTRAINT "RecurringTransactions_pkey" PRIMARY KEY ("groupId", "expenseId")
+);
+
+CREATE INDEX "idx_recurring_transactions_group_expense_next_create" ON "RecurringTransactions" ("groupId", "expenseId", "createNextAt" DESC);
+CREATE UNIQUE INDEX "idx_unq_recurring_transactions_lock_id" ON "RecurringTransactions" ("lockId");
+
+-- AlterTable
+ALTER TABLE "Expense" ADD COLUMN     "recurringDays" TEXT NOT NULL DEFAULT 0,
+                      ADD COLUMN     "isArchive" BOOLEAN NOT NULL DEFAULT false;
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index f7389472..d71504b8 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -53,6 +53,8 @@ model Expense {
   createdAt       DateTime          @default(now())
   documents       ExpenseDocument[]
   notes           String?
+  recurringDays  Int               @default(0)
+  isArchive      Boolean           @default(false)
 }
 
 model ExpenseDocument {
@@ -80,3 +82,13 @@ model ExpensePaidFor {
 
   @@id([expenseId, participantId])
 }
+
+model RecurringTransactions {
+  groupId         String
+  expenseId       String
+  createNextAt    Int
+  lockId          String?  @unique
+
+  @@id([groupId, expenseId])
+  @@index([groupId, expenseId, createNextAt(sort: Desc)])
+}
\ No newline at end of file
diff --git a/src/components/expense-form.tsx b/src/components/expense-form.tsx
index df5563da..e8a0725b 100644
--- a/src/components/expense-form.tsx
+++ b/src/components/expense-form.tsx
@@ -164,6 +164,10 @@ export function ExpenseForm({
     return field?.value
   }
   const defaultSplittingOptions = getDefaultSplittingOptions(group)
+
+  const getRecurringField = (field?: { value: string }) => {
+    return field?.value
+  }
   const form = useForm<ExpenseFormValues>({
     resolver: zodResolver(expenseFormSchema),
     defaultValues: expense
@@ -182,6 +186,8 @@ export function ExpenseForm({
           isReimbursement: expense.isReimbursement,
           documents: expense.documents,
           notes: expense.notes ?? '',
+          recurringDays: String(expense.recurringDays),
+          isArchive: expense.isArchive,
         }
       : searchParams.get('reimbursement')
       ? {
@@ -205,6 +211,8 @@ export function ExpenseForm({
           saveDefaultSplittingOptions: false,
           documents: [],
           notes: '',
+          recurringDays: "0",
+          isArchive: false,
         }
       : {
           title: searchParams.get('title') ?? '',
@@ -232,7 +240,10 @@ export function ExpenseForm({
               ]
             : [],
           notes: '',
+          recurringDays: "0",
+          isArchive: false,
         },
+        
   })
   const [isCategoryLoading, setCategoryLoading] = useState(false)
 
@@ -241,6 +252,7 @@ export function ExpenseForm({
     return onSubmit(values)
   }
 
+  const recurringDays = [{ "key": "Never","value": "0"}, { "key":"weekly", "value": "7"}, {"key": "fortnightly", "value": "14"}, {"key": "monthly", "value": "30"}, {"key": "bimonthly", "value": "60"}]
   return (
     <Form {...form}>
       <form onSubmit={form.handleSubmit(submit)}>
@@ -413,6 +425,34 @@ export function ExpenseForm({
                   <FormControl>
                     <Textarea className="text-base" {...field} />
                   </FormControl>
+                  </FormItem>
+              )}
+            />
+            <FormField
+              control={form.control}
+              name="recurringDays"
+              render={({ field }) => (
+                <FormItem className="sm:order-5">
+                  <FormLabel>Recurring Days</FormLabel>
+                  <Select
+                    onValueChange={field.onChange}
+                    defaultValue={getRecurringField(field)}
+                  >
+                    <SelectTrigger>
+                      <SelectValue placeholder="Never" />
+                    </SelectTrigger>
+                    <SelectContent>
+                      {recurringDays.map(({ key, value }) => (
+                        <SelectItem key={key} value={value}>
+                          {key}
+                        </SelectItem>
+                      ))}
+                    </SelectContent>
+                  </Select>
+                  <FormDescription>
+                    Select recursive days.
+                  </FormDescription>
+                  <FormMessage />
                 </FormItem>
               )}
             />
diff --git a/src/lib/api.ts b/src/lib/api.ts
index 1d8043a3..e9a5286c 100644
--- a/src/lib/api.ts
+++ b/src/lib/api.ts
@@ -30,6 +30,7 @@ export async function createGroup(groupFormValues: GroupFormValues) {
 export async function createExpense(
   expenseFormValues: ExpenseFormValues,
   groupId: string,
+  expenseRef: string|null = null
 ): Promise<Expense> {
   const group = await getGroup(groupId)
   if (!group) throw new Error(`Invalid group ID: ${groupId}`)
@@ -41,13 +42,42 @@ export async function createExpense(
     if (!group.participants.some((p) => p.id === participant))
       throw new Error(`Invalid participant ID: ${participant}`)
   }
-
+  const expenseId = randomId()
   const prisma = await getPrisma()
+  let expenseDate = expenseFormValues.expenseDate
+  if (+expenseFormValues.recurringDays) {
+    const nextAt: number = Math.floor((new Date(expenseDate)).getTime() / 1000) + (+expenseFormValues.recurringDays * 86400)
+    if (!isNaN(nextAt)) {
+      if (expenseRef) {
+        expenseDate = new Date(nextAt*1000)
+        await prisma.recurringTransactions.updateMany({
+          where: {
+            groupId,
+            expenseId: expenseRef
+          },
+          data: {
+            createNextAt: nextAt,
+            expenseId
+          }
+        })
+      } else {
+        await prisma.recurringTransactions.create({
+          data: {
+            groupId,
+            expenseId,
+            createNextAt: nextAt,
+            lockId: null
+          }
+        })
+      }
+    }
+  }
+
   return prisma.expense.create({
     data: {
-      id: randomId(),
+      id: expenseId,
       groupId,
-      expenseDate: expenseFormValues.expenseDate,
+      expenseDate: expenseDate,
       categoryId: expenseFormValues.category,
       amount: expenseFormValues.amount,
       title: expenseFormValues.title,
@@ -73,6 +103,8 @@ export async function createExpense(
         },
       },
       notes: expenseFormValues.notes,
+      recurringDays: +expenseFormValues.recurringDays,
+      isArchive: false,
     },
   })
 }
@@ -243,7 +275,99 @@ export async function getCategories() {
 }
 
 export async function getGroupExpenses(groupId: string) {
+  const now: number = Math.floor((new Date()).getTime() / 1000)
   const prisma = await getPrisma()
+
+  let allPendingRecurringTxns = await prisma.recurringTransactions.findMany({
+    where: {
+      groupId,
+      createNextAt: {
+        lte: now
+      },
+      lockId: null
+    }
+  })
+  let ignoreExpenseId = []
+  while(allPendingRecurringTxns.length) {
+    const relatedExpenses = await prisma.expense.findMany({
+      where: {
+        id: {
+          in: allPendingRecurringTxns.map((rt) => rt.expenseId)
+        },
+        groupId,
+      },
+      include: {
+        paidFor: { include: { participant: true } },
+        paidBy: true,
+        category: true,
+        documents: true
+      },
+    })
+    for (let i=0; i<relatedExpenses.length; ++i) {
+      const lockId =  randomId()
+      if (now < new Date(relatedExpenses[i].expenseDate).getTime()/1000 + (+relatedExpenses[i].recurringDays * 86400)) {
+        ignoreExpenseId.push(relatedExpenses[i].id)
+        continue
+      }
+      await prisma.recurringTransactions.updateMany({
+        where: {
+          groupId,
+          expenseId: relatedExpenses[i].id,
+          lockId: null
+        },
+        data: {
+          lockId
+        }
+      })
+      const getRecTxn = await prisma.recurringTransactions.findMany({
+        where: {
+          expenseId: relatedExpenses[i].id,
+          groupId,
+          lockId
+        }
+      })
+      if (getRecTxn.length) {
+        const newExpense = await createExpense({
+          expenseDate: relatedExpenses[i].expenseDate,
+          title: relatedExpenses[i].title,
+          category: relatedExpenses[i].category?.id || 0,
+          amount: relatedExpenses[i].amount,
+          paidBy: relatedExpenses[i].paidBy.id,
+          splitMode: relatedExpenses[i].splitMode,
+          paidFor: relatedExpenses[i].paidFor
+          .map((paidFor) =>  ({
+            participant: paidFor.participant.id,
+            shares: paidFor.shares,
+          })),
+          isReimbursement: relatedExpenses[i].isReimbursement,
+          documents: relatedExpenses[i].documents,
+          recurringDays: String(relatedExpenses[i].recurringDays),
+          isArchive: relatedExpenses[i].isArchive,
+        }, groupId, relatedExpenses[i].id);
+        await prisma.recurringTransactions.updateMany({
+          where: {
+            groupId,
+            expenseId: newExpense.id,
+          },
+          data: {
+            lockId: null
+          }
+        })
+      }
+    }
+    allPendingRecurringTxns = await prisma.recurringTransactions.findMany({
+      where: {
+        groupId,
+        createNextAt: {
+          lte: now
+        },
+        expenseId: {
+          notIn: ignoreExpenseId
+        },
+        lockId: null
+      }
+    })
+  }
   return prisma.expense.findMany({
     where: { groupId },
     include: {
diff --git a/src/lib/schemas.ts b/src/lib/schemas.ts
index fd624e1b..b37ea8fe 100644
--- a/src/lib/schemas.ts
+++ b/src/lib/schemas.ts
@@ -107,6 +107,8 @@ export const expenseFormSchema = z
       .default('EVENLY'),
     saveDefaultSplittingOptions: z.boolean(),
     isReimbursement: z.boolean(),
+    recurringDays: z.string({ required_error: 'You must select recurring days.' }),
+    isArchive: z.boolean(),
     documents: z
       .array(
         z.object({