diff --git a/apps/nestjs-backend/src/features/field/field-calculate/field-supplement.service.ts b/apps/nestjs-backend/src/features/field/field-calculate/field-supplement.service.ts
index 2ceebefbd..df69eb723 100644
--- a/apps/nestjs-backend/src/features/field/field-calculate/field-supplement.service.ts
+++ b/apps/nestjs-backend/src/features/field/field-calculate/field-supplement.service.ts
@@ -670,22 +670,29 @@ export class FieldSupplementService {
     };
   }
 
-  private prepareSelectOptions(options: ISelectFieldOptionsRo) {
+  private prepareSelectOptions(options: ISelectFieldOptionsRo, isMultiple: boolean) {
     const optionsRo = (options ?? SelectFieldCore.defaultOptions()) as ISelectFieldOptionsRo;
     const nameSet = new Set<string>();
+    const choices = optionsRo.choices.map((choice) => {
+      if (nameSet.has(choice.name)) {
+        throw new BadRequestException(`choice name ${choice.name} is duplicated`);
+      }
+      nameSet.add(choice.name);
+      return {
+        name: choice.name,
+        id: choice.id ?? generateChoiceId(),
+        color: choice.color ?? ColorUtils.randomColor()[0],
+      };
+    });
+
+    const defaultValue = optionsRo.defaultValue
+      ? [optionsRo.defaultValue].flat().filter((name) => nameSet.has(name))
+      : undefined;
+
     return {
       ...optionsRo,
-      choices: optionsRo.choices.map((choice) => {
-        if (nameSet.has(choice.name)) {
-          throw new BadRequestException(`choice name ${choice.name} is duplicated`);
-        }
-        nameSet.add(choice.name);
-        return {
-          name: choice.name,
-          id: choice.id ?? generateChoiceId(),
-          color: choice.color ?? ColorUtils.randomColor()[0],
-        };
-      }),
+      defaultValue: isMultiple ? defaultValue : defaultValue?.[0],
+      choices,
     };
   }
 
@@ -695,7 +702,7 @@ export class FieldSupplementService {
     return {
       ...field,
       name: name ?? 'Select',
-      options: this.prepareSelectOptions(options as ISelectFieldOptionsRo),
+      options: this.prepareSelectOptions(options as ISelectFieldOptionsRo, false),
       cellValueType: CellValueType.String,
       dbFieldType: DbFieldType.Text,
     };
@@ -707,7 +714,7 @@ export class FieldSupplementService {
     return {
       ...field,
       name: name ?? 'Tags',
-      options: this.prepareSelectOptions(options as ISelectFieldOptionsRo),
+      options: this.prepareSelectOptions(options as ISelectFieldOptionsRo, true),
       cellValueType: CellValueType.String,
       dbFieldType: DbFieldType.Json,
       isMultipleCellValue: true,
@@ -728,19 +735,27 @@ export class FieldSupplementService {
   }
 
   private async prepareUpdateUserField(fieldRo: IFieldRo, oldFieldVo: IFieldVo) {
-    const mergeObj = merge({}, oldFieldVo, fieldRo);
+    const mergeObj = {
+      ...oldFieldVo,
+      ...fieldRo,
+    };
 
     return this.prepareUserField(mergeObj);
   }
 
   private prepareUserField(field: IFieldRo) {
-    const { name, options = UserFieldCore.defaultOptions() } = field;
-    const { isMultiple } = options as IUserFieldOptions;
+    const { name } = field;
+    const options: IUserFieldOptions = field.options || UserFieldCore.defaultOptions();
+    const { isMultiple } = options;
+    const defaultValue = options.defaultValue ? [options.defaultValue].flat() : undefined;
 
     return {
       ...field,
       name: name ?? `Collaborator${isMultiple ? 's' : ''}`,
-      options: options,
+      options: {
+        ...options,
+        defaultValue: isMultiple ? defaultValue : defaultValue?.[0],
+      },
       cellValueType: CellValueType.String,
       dbFieldType: DbFieldType.Json,
       isMultipleCellValue: isMultiple || undefined,
diff --git a/apps/nestjs-backend/src/features/record/record-calculate/record-calculate.service.ts b/apps/nestjs-backend/src/features/record/record-calculate/record-calculate.service.ts
index 82b0cc68c..83d128f54 100644
--- a/apps/nestjs-backend/src/features/record/record-calculate/record-calculate.service.ts
+++ b/apps/nestjs-backend/src/features/record/record-calculate/record-calculate.service.ts
@@ -1,9 +1,11 @@
 import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
-import type { IMakeOptional } from '@teable/core';
+import type { IMakeOptional, IUserFieldOptions } from '@teable/core';
 import { FieldKeyType, generateRecordId, FieldType } from '@teable/core';
 import { PrismaService } from '@teable/db-main-prisma';
 import type { ICreateRecordsRo, ICreateRecordsVo, IRecord } from '@teable/openapi';
-import { isEmpty, keyBy } from 'lodash';
+import { isEmpty, keyBy, uniq } from 'lodash';
+import { ClsService } from 'nestjs-cls';
+import type { IClsStore } from '../../../types/cls';
 import { BatchService } from '../../calculation/batch.service';
 import { FieldCalculationService } from '../../calculation/field-calculation.service';
 import { LinkService } from '../../calculation/link.service';
@@ -24,7 +26,8 @@ export class RecordCalculateService {
     private readonly recordService: RecordService,
     private readonly linkService: LinkService,
     private readonly referenceService: ReferenceService,
-    private readonly fieldCalculationService: FieldCalculationService
+    private readonly fieldCalculationService: FieldCalculationService,
+    private readonly clsService: ClsService<IClsStore>
   ) {}
 
   async multipleCreateRecords(
@@ -201,16 +204,17 @@ export class RecordCalculateService {
     fieldKeyType: FieldKeyType,
     fieldRaws: IFieldRaws
   ) {
-    return records.map((record) => {
+    const processedRecords = records.map((record) => {
       const fields: { [fieldIdOrName: string]: unknown } = { ...record.fields };
       for (const fieldRaw of fieldRaws) {
-        const { type, options } = fieldRaw;
-        if (options == null) continue;
-        const { defaultValue } = JSON.parse(options) || {};
+        const { type, options, isComputed } = fieldRaw;
+        if (options == null || isComputed) continue;
+        const optionsObj = JSON.parse(options) || {};
+        const { defaultValue } = optionsObj;
         if (defaultValue == null) continue;
         const fieldIdOrName = fieldRaw[fieldKeyType];
         if (fields[fieldIdOrName] != null) continue;
-        fields[fieldIdOrName] = this.getDefaultValue(type as FieldType, defaultValue);
+        fields[fieldIdOrName] = this.getDefaultValue(type as FieldType, optionsObj, defaultValue);
       }
 
       return {
@@ -218,13 +222,112 @@ export class RecordCalculateService {
         fields,
       };
     });
+
+    // After process to handle user field
+    const userFields = fieldRaws.filter((fieldRaw) => fieldRaw.type === FieldType.User);
+    if (userFields.length > 0) {
+      return await this.fillUserInfo(processedRecords, userFields, fieldKeyType);
+    }
+
+    return processedRecords;
+  }
+
+  private async fillUserInfo(
+    records: { id: string; fields: { [fieldNameOrId: string]: unknown } }[],
+    userFields: IFieldRaws,
+    fieldKeyType: FieldKeyType
+  ) {
+    const userIds = new Set<string>();
+    records.forEach((record) => {
+      userFields.forEach((field) => {
+        const fieldIdOrName = field[fieldKeyType];
+        const value = record.fields[fieldIdOrName];
+        if (value) {
+          if (Array.isArray(value)) {
+            value.forEach((v) => userIds.add(v.id));
+          } else {
+            userIds.add((value as { id: string }).id);
+          }
+        }
+      });
+    });
+
+    const userInfo = await this.getUserInfoFromDatabase(Array.from(userIds));
+
+    return records.map((record) => {
+      const updatedFields = { ...record.fields };
+      userFields.forEach((field) => {
+        const fieldIdOrName = field[fieldKeyType];
+        const value = updatedFields[fieldIdOrName];
+        if (value) {
+          if (Array.isArray(value)) {
+            updatedFields[fieldIdOrName] = value.map((v) => ({
+              ...v,
+              ...userInfo[v.id],
+            }));
+          } else {
+            updatedFields[fieldIdOrName] = {
+              ...value,
+              ...userInfo[(value as { id: string }).id],
+            };
+          }
+        }
+      });
+      return {
+        ...record,
+        fields: updatedFields,
+      };
+    });
+  }
+
+  private async getUserInfoFromDatabase(
+    userIds: string[]
+  ): Promise<{ [id: string]: { id: string; title: string; email: string } }> {
+    const usersRaw = await this.prismaService.txClient().user.findMany({
+      where: {
+        id: { in: userIds },
+        deletedTime: null,
+      },
+      select: {
+        id: true,
+        name: true,
+        email: true,
+      },
+    });
+    return keyBy(
+      usersRaw.map((user) => ({ id: user.id, title: user.name, email: user.email })),
+      'id'
+    );
+  }
+
+  private transformUserDefaultValue(options: IUserFieldOptions, defaultValue: string | string[]) {
+    const currentUserId = this.clsService.get('user.id');
+    const defaultIds = uniq([defaultValue].flat().map((id) => (id === 'me' ? currentUserId : id)));
+
+    if (options.isMultiple) {
+      return defaultIds.map((id) => ({ id }));
+    }
+    return defaultIds[0] ? { id: defaultIds[0] } : undefined;
   }
 
-  private getDefaultValue(type: FieldType, defaultValue: unknown) {
-    if (type === FieldType.Date && defaultValue === 'now') {
-      return new Date().toISOString();
+  private getDefaultValue(type: FieldType, options: unknown, defaultValue: unknown) {
+    switch (type) {
+      case FieldType.Date:
+        return defaultValue === 'now' ? new Date().toISOString() : defaultValue;
+      case FieldType.SingleSelect:
+        return Array.isArray(defaultValue) ? defaultValue[0] : defaultValue;
+      case FieldType.MultipleSelect:
+        return Array.isArray(defaultValue) ? defaultValue : [defaultValue];
+      case FieldType.User:
+        return this.transformUserDefaultValue(
+          options as IUserFieldOptions,
+          defaultValue as string | string[]
+        );
+      case FieldType.Checkbox:
+        return defaultValue ? true : null;
+      default:
+        return defaultValue;
     }
-    return defaultValue;
   }
 
   async createRecords(
@@ -253,6 +356,7 @@ export class RecordCalculateService {
         options: true,
         unique: true,
         notNull: true,
+        isComputed: true,
         isLookup: true,
         dbFieldName: true,
       },
diff --git a/apps/nestjs-backend/src/features/record/type.ts b/apps/nestjs-backend/src/features/record/type.ts
index 78313240f..af8ec7750 100644
--- a/apps/nestjs-backend/src/features/record/type.ts
+++ b/apps/nestjs-backend/src/features/record/type.ts
@@ -2,5 +2,13 @@ import type { Field } from '@prisma/client';
 
 export type IFieldRaws = Pick<
   Field,
-  'id' | 'name' | 'type' | 'options' | 'unique' | 'notNull' | 'isLookup' | 'dbFieldName'
+  | 'id'
+  | 'name'
+  | 'type'
+  | 'options'
+  | 'unique'
+  | 'notNull'
+  | 'isComputed'
+  | 'isLookup'
+  | 'dbFieldName'
 >[];
diff --git a/apps/nestjs-backend/test/record.e2e-spec.ts b/apps/nestjs-backend/test/record.e2e-spec.ts
index 72b37ea45..eae422169 100644
--- a/apps/nestjs-backend/test/record.e2e-spec.ts
+++ b/apps/nestjs-backend/test/record.e2e-spec.ts
@@ -24,6 +24,7 @@ describe('OpenAPI RecordController (e2e)', () => {
   let app: INestApplication;
 
   const baseId = globalThis.testConfig.baseId;
+  const userId = globalThis.testConfig.userId;
 
   beforeAll(async () => {
     const appCtx = await initApp();
@@ -561,4 +562,130 @@ describe('OpenAPI RecordController (e2e)', () => {
       expect(data.records[0].fields[rollup.id]).toBeUndefined();
     });
   });
+
+  describe('create record with default value', () => {
+    let table: ITableFullVo;
+    beforeAll(async () => {
+      table = await createTable(baseId, {
+        name: 'table1',
+      });
+    });
+
+    afterAll(async () => {
+      await permanentDeleteTable(baseId, table.id);
+    });
+
+    it('should create a record with default single select', async () => {
+      const field = await createField(table.id, {
+        type: FieldType.SingleSelect,
+        options: {
+          choices: [{ name: 'default value' }],
+          defaultValue: 'default value',
+        },
+      });
+
+      const { records } = await createRecords(table.id, {
+        records: [
+          {
+            fields: {},
+          },
+        ],
+      });
+
+      expect(records[0].fields[field.id]).toEqual('default value');
+    });
+
+    it('should create a record with default multiple select', async () => {
+      const field = await createField(table.id, {
+        type: FieldType.MultipleSelect,
+        options: {
+          choices: [{ name: 'default value' }, { name: 'default value2' }],
+          defaultValue: ['default value', 'default value2'],
+        },
+      });
+
+      const { records } = await createRecords(table.id, {
+        records: [
+          {
+            fields: {},
+          },
+        ],
+      });
+
+      expect(records[0].fields[field.id]).toEqual(['default value', 'default value2']);
+    });
+
+    it('should create a record with default number', async () => {
+      const field = await createField(table.id, {
+        type: FieldType.Number,
+        options: {
+          defaultValue: 1,
+        },
+      });
+
+      const { records } = await createRecords(table.id, {
+        records: [
+          {
+            fields: {},
+          },
+        ],
+      });
+
+      expect(records[0].fields[field.id]).toEqual(1);
+    });
+
+    it('should create a record with default user', async () => {
+      const field = await createField(table.id, {
+        type: FieldType.User,
+        options: {
+          defaultValue: userId,
+        },
+      });
+      const field2 = await createField(table.id, {
+        type: FieldType.User,
+        options: {
+          isMultiple: true,
+          defaultValue: ['me'],
+        },
+      });
+      const field3 = await createField(table.id, {
+        type: FieldType.User,
+        options: {
+          isMultiple: true,
+          defaultValue: [userId],
+        },
+      });
+
+      const { records } = await createRecords(table.id, {
+        records: [
+          {
+            fields: {},
+          },
+        ],
+      });
+
+      expect(records[0].fields[field.id]).toMatchObject({
+        id: userId,
+        title: expect.any(String),
+        email: expect.any(String),
+        avatarUrl: expect.any(String),
+      });
+      expect(records[0].fields[field2.id]).toMatchObject([
+        {
+          id: userId,
+          title: expect.any(String),
+          email: expect.any(String),
+          avatarUrl: expect.any(String),
+        },
+      ]);
+      expect(records[0].fields[field3.id]).toMatchObject([
+        {
+          id: userId,
+          title: expect.any(String),
+          email: expect.any(String),
+          avatarUrl: expect.any(String),
+        },
+      ]);
+    });
+  });
 });
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/DefaultValue.tsx b/apps/nextjs-app/src/features/app/components/field-setting/DefaultValue.tsx
new file mode 100644
index 000000000..f235e8d17
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/components/field-setting/DefaultValue.tsx
@@ -0,0 +1,33 @@
+import { Label } from '@teable/ui-lib/shadcn';
+import { useTranslation } from 'next-i18next';
+import React from 'react';
+import { tableConfig } from '@/features/i18n/table.config';
+
+export const DefaultValue = (props: { children: React.ReactNode; onReset?: () => void }) => {
+  const { children, onReset } = props;
+  const { t } = useTranslation(tableConfig.i18nNamespaces);
+
+  return (
+    <div className="flex w-full flex-col gap-2">
+      <Label className="flex justify-between font-normal">
+        {t('table:field.editor.defaultValue')}
+        {onReset && (
+          <span
+            onKeyDown={(e) => {
+              if (e.key === 'Enter' || e.key === ' ') {
+                onReset();
+              }
+            }}
+            onClick={() => onReset()}
+            tabIndex={0}
+            role={'button'}
+            className="cursor-pointer border-b border-solid border-slate-500 text-xs text-slate-500"
+          >
+            {t('table:field.editor.reset')}
+          </span>
+        )}
+      </Label>
+      {children}
+    </div>
+  );
+};
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/FieldOptions.tsx b/apps/nextjs-app/src/features/app/components/field-setting/FieldOptions.tsx
index 6d375d597..e5dfa835f 100644
--- a/apps/nextjs-app/src/features/app/components/field-setting/FieldOptions.tsx
+++ b/apps/nextjs-app/src/features/app/components/field-setting/FieldOptions.tsx
@@ -11,16 +11,20 @@ import type {
   ICreatedTimeFieldOptions,
   ILastModifiedTimeFieldOptions,
   IUserFieldOptions,
+  ICheckboxFieldOptions,
+  ILongTextFieldOptions,
 } from '@teable/core';
 import { FieldType } from '@teable/core';
+import { CheckboxOptions } from './options/CheckboxOptions';
 import { CreatedTimeOptions } from './options/CreatedTimeOptions';
 import { DateOptions } from './options/DateOptions';
 import { FormulaOptions } from './options/FormulaOptions';
 import { LinkOptions } from './options/LinkOptions';
+import { LongTextOptions } from './options/LongTextOptions';
 import { NumberOptions } from './options/NumberOptions';
 import { RatingOptions } from './options/RatingOptions';
 import { RollupOptions } from './options/RollupOptions';
-import { SelectOptions } from './options/SelectOptions';
+import { SelectOptions } from './options/SelectOptions/SelectOptions';
 import { SingleLineTextOptions } from './options/SingleLineTextOptions';
 import { UserOptions } from './options/UserOptions';
 import type { IFieldEditorRo } from './type';
@@ -36,14 +40,24 @@ export const FieldOptions: React.FC<IFieldOptionsProps> = ({ field, onChange })
     case FieldType.SingleLineText:
       return (
         <SingleLineTextOptions
+          isLookup={isLookup}
           options={options as ISingleLineTextFieldOptions}
           onChange={onChange}
         />
       );
+    case FieldType.LongText:
+      return (
+        <LongTextOptions
+          options={options as ILongTextFieldOptions}
+          isLookup={isLookup}
+          onChange={onChange}
+        />
+      );
     case FieldType.SingleSelect:
     case FieldType.MultipleSelect:
       return (
         <SelectOptions
+          isMultiple={type === FieldType.MultipleSelect}
           options={options as ISelectFieldOptions}
           isLookup={isLookup}
           onChange={onChange}
@@ -111,6 +125,14 @@ export const FieldOptions: React.FC<IFieldOptionsProps> = ({ field, onChange })
           onChange={onChange}
         />
       );
+    case FieldType.Checkbox:
+      return (
+        <CheckboxOptions
+          options={options as ICheckboxFieldOptions}
+          isLookup={isLookup}
+          onChange={onChange}
+        />
+      );
     case FieldType.Rollup:
       return (
         <RollupOptions
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/options/CheckboxOptions.tsx b/apps/nextjs-app/src/features/app/components/field-setting/options/CheckboxOptions.tsx
new file mode 100644
index 000000000..6b10dcc29
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/components/field-setting/options/CheckboxOptions.tsx
@@ -0,0 +1,29 @@
+import type { ICheckboxFieldOptions } from '@teable/core';
+import { Checkbox } from '@teable/ui-lib/shadcn';
+import { DefaultValue } from '../DefaultValue';
+
+export const CheckboxOptions = (props: {
+  options: Partial<ICheckboxFieldOptions> | undefined;
+  onChange?: (options: Partial<ICheckboxFieldOptions>) => void;
+  isLookup?: boolean;
+}) => {
+  const { isLookup, options, onChange } = props;
+  const onDefaultValueChange = (defaultValue: boolean | undefined) => {
+    onChange?.({
+      defaultValue: defaultValue || undefined,
+    });
+  };
+
+  return (
+    <div className="form-control space-y-2">
+      {!isLookup && (
+        <DefaultValue>
+          <Checkbox
+            checked={options?.defaultValue || false}
+            onCheckedChange={(checked: boolean) => onDefaultValueChange(checked)}
+          />
+        </DefaultValue>
+      )}
+    </div>
+  );
+};
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/options/LongTextOptions.tsx b/apps/nextjs-app/src/features/app/components/field-setting/options/LongTextOptions.tsx
new file mode 100644
index 000000000..e1b11c39c
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/components/field-setting/options/LongTextOptions.tsx
@@ -0,0 +1,32 @@
+import type { ILongTextFieldOptions } from '@teable/core';
+import { Textarea } from '@teable/ui-lib/shadcn';
+import { DefaultValue } from '../DefaultValue';
+
+export const LongTextOptions = (props: {
+  options: Partial<ILongTextFieldOptions> | undefined;
+  onChange?: (options: Partial<ILongTextFieldOptions>) => void;
+  isLookup?: boolean;
+}) => {
+  const { isLookup, options, onChange } = props;
+
+  const onDefaultValueChange = (defaultValue: string | undefined) => {
+    onChange?.({
+      defaultValue,
+    });
+  };
+
+  return (
+    <div className="form-control space-y-2">
+      {!isLookup && (
+        <DefaultValue onReset={() => onDefaultValueChange(undefined)}>
+          <Textarea
+            className="w-full"
+            value={options?.defaultValue || ''}
+            onChange={(e) => onDefaultValueChange(e.target.value)}
+            rows={3}
+          />
+        </DefaultValue>
+      )}
+    </div>
+  );
+};
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/options/NumberOptions.tsx b/apps/nextjs-app/src/features/app/components/field-setting/options/NumberOptions.tsx
index 5737f0a51..532f355be 100644
--- a/apps/nextjs-app/src/features/app/components/field-setting/options/NumberOptions.tsx
+++ b/apps/nextjs-app/src/features/app/components/field-setting/options/NumberOptions.tsx
@@ -1,4 +1,6 @@
 import type { INumberShowAs, INumberFormatting, INumberFieldOptions } from '@teable/core';
+import { Input } from '@teable/ui-lib/shadcn';
+import { DefaultValue } from '../DefaultValue';
 import { NumberFormatting } from '../formatting/NumberFormatting';
 import { MultiNumberShowAs } from '../show-as/MultiNumberShowAs';
 import { SingleNumberShowAs } from '../show-as/SingleNumberShowAs';
@@ -9,7 +11,7 @@ export const NumberOptions = (props: {
   isMultipleCellValue?: boolean;
   onChange?: (options: Partial<INumberFieldOptions>) => void;
 }) => {
-  const { options, isMultipleCellValue, onChange } = props;
+  const { isLookup, options, isMultipleCellValue, onChange } = props;
 
   const ShowAsComponent = isMultipleCellValue ? MultiNumberShowAs : SingleNumberShowAs;
 
@@ -25,9 +27,24 @@ export const NumberOptions = (props: {
     });
   };
 
+  const onDefaultValueChange = (defaultValue: number | undefined) => {
+    onChange?.({
+      defaultValue,
+    });
+  };
+
   return (
     <div className="form-control space-y-2">
       <NumberFormatting formatting={options?.formatting} onChange={onFormattingChange} />
+      {!isLookup && (
+        <DefaultValue onReset={() => onDefaultValueChange(undefined)}>
+          <Input
+            type="number"
+            value={options?.defaultValue || ''}
+            onChange={(e) => onDefaultValueChange(Number(e.target.value))}
+          />
+        </DefaultValue>
+      )}
       <ShowAsComponent showAs={options?.showAs as never} onChange={onShowAsChange} />
     </div>
   );
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions/ChoiceItem.tsx b/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions/ChoiceItem.tsx
new file mode 100644
index 000000000..3c773daf1
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions/ChoiceItem.tsx
@@ -0,0 +1,80 @@
+import type { ISelectFieldChoice } from '@teable/core';
+import { ColorUtils } from '@teable/core';
+import { Popover, PopoverTrigger, Button, PopoverContent, Input } from '@teable/ui-lib/shadcn';
+import { useState } from 'react';
+import { ColorPicker } from './ColorPicker';
+
+interface IOptionItemProps {
+  choice: ISelectFieldChoice;
+  readonly?: boolean;
+  onChange: (key: keyof ISelectFieldChoice, value: string) => void;
+  onKeyDown?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+  onInputRef?: (el: HTMLInputElement | null) => void;
+}
+
+export const ChoiceItem = (props: IOptionItemProps) => {
+  const { choice, readonly, onChange, onKeyDown, onInputRef } = props;
+  const { color, name } = choice;
+  const bgColor = ColorUtils.getHexForColor(color);
+
+  return (
+    <li className="flex grow items-center">
+      {readonly ? (
+        <div className="h-auto rounded-full border-2 p-[2px]" style={{ borderColor: bgColor }}>
+          <div style={{ backgroundColor: bgColor }} className="size-3 rounded-full" />
+        </div>
+      ) : (
+        <Popover>
+          <PopoverTrigger>
+            <Button
+              variant={'ghost'}
+              className="h-auto rounded-full border-2 p-[2px]"
+              style={{ borderColor: bgColor }}
+            >
+              <div style={{ backgroundColor: bgColor }} className="size-3 rounded-full" />
+            </Button>
+          </PopoverTrigger>
+          <PopoverContent className="w-auto p-2">
+            <ColorPicker color={color} onSelect={(color) => onChange('color', color)} />
+          </PopoverContent>
+        </Popover>
+      )}
+      <div className="flex-1 px-2">
+        <ChoiceInput
+          reRef={(el) => onInputRef?.(el)}
+          name={name}
+          readOnly={readonly}
+          onKeyDown={(e) => onKeyDown?.(e)}
+          onChange={(value) => onChange('name', value)}
+        />
+      </div>
+    </li>
+  );
+};
+
+export const ChoiceInput: React.FC<{
+  reRef: React.Ref<HTMLInputElement>;
+  readOnly?: boolean;
+  name: string;
+  onChange: (name: string) => void;
+  onKeyDown?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+}> = ({ name, readOnly, onChange, onKeyDown, reRef }) => {
+  const [value, setValue] = useState<string>(name);
+  const onChangeInner = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const curValue = e.target.value;
+    setValue(curValue);
+  };
+
+  return (
+    <Input
+      ref={reRef}
+      className="h-7"
+      type="text"
+      value={value}
+      readOnly={readOnly}
+      onChange={onChangeInner}
+      onKeyDown={onKeyDown}
+      onBlur={() => onChange(value)}
+    />
+  );
+};
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions/ColorPicker.tsx b/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions/ColorPicker.tsx
new file mode 100644
index 000000000..479f10170
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions/ColorPicker.tsx
@@ -0,0 +1,47 @@
+import type { Colors } from '@teable/core';
+import { COLOR_PALETTE, ColorUtils } from '@teable/core';
+import { Button, cn } from '@teable/ui-lib/shadcn';
+
+export const ColorPicker = ({
+  color,
+  onSelect,
+}: {
+  color: Colors;
+  onSelect: (color: Colors) => void;
+}) => {
+  return (
+    <div className="flex w-64 flex-wrap p-2">
+      {COLOR_PALETTE.map((group, index) => {
+        return (
+          <div key={index}>
+            {group.map((c) => {
+              const bg = ColorUtils.getHexForColor(c);
+
+              return (
+                <Button
+                  key={c}
+                  variant={'ghost'}
+                  className={cn('p-1 my-1 rounded-full h-auto', {
+                    'border-2 p-[2px]': color === c,
+                  })}
+                  style={{ borderColor: bg }}
+                  onMouseDown={(e) => {
+                    e.stopPropagation();
+                    onSelect(c);
+                  }}
+                >
+                  <div
+                    style={{
+                      backgroundColor: bg,
+                    }}
+                    className="size-4 rounded-full"
+                  />
+                </Button>
+              );
+            })}
+          </div>
+        );
+      })}
+    </div>
+  );
+};
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions/SelectDefaultValue.tsx b/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions/SelectDefaultValue.tsx
new file mode 100644
index 000000000..b34bc023d
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions/SelectDefaultValue.tsx
@@ -0,0 +1,22 @@
+import type { ISelectFieldOptions } from '@teable/core';
+import { SelectEditor, transformSelectOptions } from '@teable/sdk/components';
+import { DefaultValue } from '../../DefaultValue';
+
+interface ISelectDefaultValue {
+  isMultiple: boolean;
+  onChange: (value: string | string[] | undefined) => void;
+  options: Partial<ISelectFieldOptions> | undefined;
+}
+
+export const SelectDefaultValue = ({ isMultiple, onChange, options }: ISelectDefaultValue) => {
+  return (
+    <DefaultValue onReset={() => onChange(undefined)}>
+      <SelectEditor
+        value={options?.defaultValue}
+        options={transformSelectOptions(options?.choices ?? [])}
+        onChange={onChange}
+        isMultiple={isMultiple}
+      />
+    </DefaultValue>
+  );
+};
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions.tsx b/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions/SelectOptions.tsx
similarity index 63%
rename from apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions.tsx
rename to apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions/SelectOptions.tsx
index 394f01113..0bf0419de 100644
--- a/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions.tsx
+++ b/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions/SelectOptions.tsx
@@ -1,25 +1,18 @@
 import type { DropResult } from '@hello-pangea/dnd';
 import { DragDropContext, Draggable, Droppable } from '@hello-pangea/dnd';
-import type { ISelectFieldChoice, ISelectFieldOptions, Colors } from '@teable/core';
-import { COLOR_PALETTE, ColorUtils } from '@teable/core';
+import type { ISelectFieldChoice, ISelectFieldOptions } from '@teable/core';
+import { ColorUtils } from '@teable/core';
 import { DraggableHandle, Plus, Trash } from '@teable/icons';
-import { Input, cn } from '@teable/ui-lib/shadcn';
+import { cn } from '@teable/ui-lib/shadcn';
 import { Button } from '@teable/ui-lib/shadcn/ui/button';
-import { Popover, PopoverContent, PopoverTrigger } from '@teable/ui-lib/shadcn/ui/popover';
 import { useTranslation } from 'next-i18next';
-import { useMemo, useRef, useState } from 'react';
+import { useMemo, useRef } from 'react';
 import type { VirtuosoHandle } from 'react-virtuoso';
 import { Virtuoso } from 'react-virtuoso';
 import { HeightPreservingItem } from '@/features/app/blocks/view/kanban/components/KanbanStack';
 import { tableConfig } from '@/features/i18n/table.config';
-
-interface IOptionItemProps {
-  choice: ISelectFieldChoice;
-  readonly?: boolean;
-  onChange: (key: keyof ISelectFieldChoice, value: string) => void;
-  onKeyDown?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
-  onInputRef?: (el: HTMLInputElement | null) => void;
-}
+import { ChoiceItem } from './ChoiceItem';
+import { SelectDefaultValue } from './SelectDefaultValue';
 
 const getChoiceId = (choice: ISelectFieldChoice, index: number) => {
   const { id, color, name } = choice;
@@ -27,11 +20,12 @@ const getChoiceId = (choice: ISelectFieldChoice, index: number) => {
 };
 
 export const SelectOptions = (props: {
+  isMultiple: boolean;
   options: Partial<ISelectFieldOptions> | undefined;
   isLookup?: boolean;
   onChange?: (options: Partial<ISelectFieldOptions>) => void;
 }) => {
-  const { options, isLookup, onChange } = props;
+  const { isMultiple, options, isLookup, onChange } = props;
   const virtuosoRef = useRef<VirtuosoHandle>(null);
   const inputRefs = useRef<(HTMLInputElement | null)[]>([]);
   const { t } = useTranslation(tableConfig.i18nNamespaces);
@@ -51,6 +45,10 @@ export const SelectOptions = (props: {
     onChange?.({ choices: newChoice });
   };
 
+  const onDefaultValueChange = (defaultValue: string | string[] | undefined) => {
+    onChange?.({ defaultValue });
+  };
+
   const deleteChoice = (index: number) => {
     onChange?.({
       choices: choices.filter((_, i) => i !== index),
@@ -95,7 +93,7 @@ export const SelectOptions = (props: {
 
   return (
     <div className="flex grow flex-col space-y-2">
-      <div className="grow">
+      <div className="grow" style={{ maxHeight: choices.length * 36 }}>
         <DragDropContext onDragEnd={onDragEnd}>
           <Droppable
             droppableId={'select-choice-container'}
@@ -197,129 +195,25 @@ export const SelectOptions = (props: {
         </DragDropContext>
       </div>
       {!isLookup && (
-        <div className="mt-1 shrink-0">
-          <Button
-            className="w-full gap-2 text-sm font-normal"
-            size={'sm'}
-            variant={'outline'}
-            onClick={addOption}
-          >
-            <Plus className="size-4" />
-            {t('table:field.editor.addOption')}
-          </Button>
-        </div>
-      )}
-    </div>
-  );
-};
-
-export const ChoiceItem = (props: IOptionItemProps) => {
-  const { choice, readonly, onChange, onKeyDown, onInputRef } = props;
-  const { color, name } = choice;
-  const bgColor = ColorUtils.getHexForColor(color);
-
-  return (
-    <li className="flex grow items-center">
-      {readonly ? (
-        <div className="h-auto rounded-full border-2 p-[2px]" style={{ borderColor: bgColor }}>
-          <div style={{ backgroundColor: bgColor }} className="size-3 rounded-full" />
-        </div>
-      ) : (
-        <Popover>
-          <PopoverTrigger>
+        <>
+          <div className="mt-1 shrink-0">
             <Button
-              variant={'ghost'}
-              className="h-auto rounded-full border-2 p-[2px]"
-              style={{ borderColor: bgColor }}
+              className="w-full gap-2 text-sm font-normal"
+              size={'sm'}
+              variant={'outline'}
+              onClick={addOption}
             >
-              <div style={{ backgroundColor: bgColor }} className="size-3 rounded-full" />
+              <Plus className="size-4" />
+              {t('table:field.editor.addOption')}
             </Button>
-          </PopoverTrigger>
-          <PopoverContent className="w-auto p-2">
-            <ColorPicker color={color} onSelect={(color) => onChange('color', color)} />
-          </PopoverContent>
-        </Popover>
-      )}
-      <div className="flex-1 px-2">
-        <ChoiceInput
-          reRef={(el) => onInputRef?.(el)}
-          name={name}
-          readOnly={readonly}
-          onKeyDown={(e) => onKeyDown?.(e)}
-          onChange={(value) => onChange('name', value)}
-        />
-      </div>
-    </li>
-  );
-};
-
-export const ChoiceInput: React.FC<{
-  reRef: React.Ref<HTMLInputElement>;
-  readOnly?: boolean;
-  name: string;
-  onChange: (name: string) => void;
-  onKeyDown?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
-}> = ({ name, readOnly, onChange, onKeyDown, reRef }) => {
-  const [value, setValue] = useState<string>(name);
-  const onChangeInner = (e: React.ChangeEvent<HTMLInputElement>) => {
-    const curValue = e.target.value;
-    setValue(curValue);
-  };
-
-  return (
-    <Input
-      ref={reRef}
-      className="h-7"
-      type="text"
-      value={value}
-      readOnly={readOnly}
-      onChange={onChangeInner}
-      onKeyDown={onKeyDown}
-      onBlur={() => onChange(value)}
-    />
-  );
-};
-
-export const ColorPicker = ({
-  color,
-  onSelect,
-}: {
-  color: Colors;
-  onSelect: (color: Colors) => void;
-}) => {
-  return (
-    <div className="flex w-64 flex-wrap p-2">
-      {COLOR_PALETTE.map((group, index) => {
-        return (
-          <div key={index}>
-            {group.map((c) => {
-              const bg = ColorUtils.getHexForColor(c);
-
-              return (
-                <Button
-                  key={c}
-                  variant={'ghost'}
-                  className={cn('p-1 my-1 rounded-full h-auto', {
-                    'border-2 p-[2px]': color === c,
-                  })}
-                  style={{ borderColor: bg }}
-                  onMouseDown={(e) => {
-                    e.stopPropagation();
-                    onSelect(c);
-                  }}
-                >
-                  <div
-                    style={{
-                      backgroundColor: bg,
-                    }}
-                    className="size-4 rounded-full"
-                  />
-                </Button>
-              );
-            })}
           </div>
-        );
-      })}
+          <SelectDefaultValue
+            isMultiple={isMultiple}
+            onChange={onDefaultValueChange}
+            options={options}
+          />
+        </>
+      )}
     </div>
   );
 };
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions/index.ts b/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions/index.ts
new file mode 100644
index 000000000..53a6a9568
--- /dev/null
+++ b/apps/nextjs-app/src/features/app/components/field-setting/options/SelectOptions/index.ts
@@ -0,0 +1,3 @@
+export * from './ChoiceItem';
+export * from './ColorPicker';
+export * from './SelectOptions';
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/options/SingleLineTextOptions.tsx b/apps/nextjs-app/src/features/app/components/field-setting/options/SingleLineTextOptions.tsx
index a642f248d..fce21978d 100644
--- a/apps/nextjs-app/src/features/app/components/field-setting/options/SingleLineTextOptions.tsx
+++ b/apps/nextjs-app/src/features/app/components/field-setting/options/SingleLineTextOptions.tsx
@@ -1,11 +1,14 @@
 import type { ISingleLineTextFieldOptions, ISingleLineTextShowAs } from '@teable/core';
+import { Input } from '@teable/ui-lib/shadcn';
+import { DefaultValue } from '../DefaultValue';
 import { SingleTextLineShowAs } from '../show-as/SingleLineTextShowAs';
 
 export const SingleLineTextOptions = (props: {
   options: Partial<ISingleLineTextFieldOptions> | undefined;
   onChange?: (options: Partial<ISingleLineTextFieldOptions>) => void;
+  isLookup?: boolean;
 }) => {
-  const { options, onChange } = props;
+  const { isLookup, options, onChange } = props;
 
   const onShowAsChange = (showAs?: ISingleLineTextShowAs) => {
     onChange?.({
@@ -13,8 +16,23 @@ export const SingleLineTextOptions = (props: {
     });
   };
 
+  const onDefaultValueChange = (defaultValue: string | undefined) => {
+    onChange?.({
+      defaultValue,
+    });
+  };
+
   return (
     <div className="form-control space-y-2">
+      {!isLookup && (
+        <DefaultValue onReset={() => onDefaultValueChange(undefined)}>
+          <Input
+            type="text"
+            value={options?.defaultValue || ''}
+            onChange={(e) => onDefaultValueChange(e.target.value)}
+          />
+        </DefaultValue>
+      )}
       <SingleTextLineShowAs showAs={options?.showAs as never} onChange={onShowAsChange} />
     </div>
   );
diff --git a/apps/nextjs-app/src/features/app/components/field-setting/options/UserOptions.tsx b/apps/nextjs-app/src/features/app/components/field-setting/options/UserOptions.tsx
index c675c2959..8b5a63392 100644
--- a/apps/nextjs-app/src/features/app/components/field-setting/options/UserOptions.tsx
+++ b/apps/nextjs-app/src/features/app/components/field-setting/options/UserOptions.tsx
@@ -1,7 +1,14 @@
-import type { CellValueType, IUserFieldOptions } from '@teable/core';
+import { useQuery } from '@tanstack/react-query';
+import type { CellValueType, IUserCellValue, IUserFieldOptions } from '@teable/core';
+import { getBaseCollaboratorList } from '@teable/openapi';
+import { UserEditor } from '@teable/sdk/components';
+import { ReactQueryKeys } from '@teable/sdk/config';
+import { useBaseId } from '@teable/sdk/hooks';
 import { Label, Switch } from '@teable/ui-lib';
+import { keyBy } from 'lodash';
 import { useTranslation } from 'next-i18next';
 import { tableConfig } from '@/features/i18n/table.config';
+import { DefaultValue } from '../DefaultValue';
 
 export const UserOptions = (props: {
   options: Partial<IUserFieldOptions> | undefined;
@@ -12,6 +19,12 @@ export const UserOptions = (props: {
   const { options = {}, isLookup, onChange } = props;
   const { isMultiple, shouldNotify } = options;
   const { t } = useTranslation(tableConfig.i18nNamespaces);
+  const baseId = useBaseId();
+
+  const { data: collaborators, isLoading } = useQuery({
+    queryKey: ReactQueryKeys.baseCollaboratorList(baseId as string),
+    queryFn: ({ queryKey }) => getBaseCollaboratorList(queryKey[1]).then((res) => res.data),
+  });
 
   const onIsMultipleChange = (checked: boolean) => {
     onChange?.({
@@ -25,6 +38,50 @@ export const UserOptions = (props: {
     });
   };
 
+  const onDefaultValueChange = (defaultValue: IUserCellValue | IUserCellValue[] | undefined) => {
+    onChange?.({
+      defaultValue: Array.isArray(defaultValue) ? defaultValue.map((v) => v.id) : defaultValue?.id,
+    });
+  };
+
+  const defaultValueToUser = (
+    options: IUserFieldOptions
+  ): IUserCellValue | IUserCellValue[] | undefined => {
+    if (!options.defaultValue || !collaborators) return undefined;
+    const userMap = keyBy<{
+      userName: string;
+      userId: string;
+      email: string;
+      avatar?: string | null;
+    }>(collaborators, 'userId');
+    userMap['me'] = {
+      userName: t('sdk:filter.currentUser'),
+      userId: 'me',
+      email: '',
+    };
+    const { defaultValue, isMultiple } = options;
+    const values = [defaultValue].flat();
+    if (isMultiple) {
+      return values
+        .filter((id) => userMap[id])
+        .map((id) => ({
+          title: userMap[id].userName,
+          id: userMap[id].userId,
+          email: userMap[id].email,
+          avatarUrl: userMap[id].avatar,
+        }));
+    }
+
+    const user = userMap[values[0]];
+    if (!user) return undefined;
+    return {
+      title: user.userName,
+      id: user.userId,
+      email: user.email,
+      avatarUrl: user.avatar,
+    };
+  };
+
   return (
     <div className="form-control space-y-2">
       {!isLookup && (
@@ -49,6 +106,16 @@ export const UserOptions = (props: {
               {t('table:field.editor.notifyUsers')}
             </Label>
           </div>
+          {!isLoading && (
+            <DefaultValue onReset={() => onDefaultValueChange(undefined)}>
+              <UserEditor
+                value={defaultValueToUser(options)}
+                onChange={onDefaultValueChange}
+                options={options}
+                includeMe
+              />
+            </DefaultValue>
+          )}
         </div>
       )}
     </div>
diff --git a/packages/common-i18n/src/locales/en/table.json b/packages/common-i18n/src/locales/en/table.json
index 9382857f2..c00795380 100644
--- a/packages/common-i18n/src/locales/en/table.json
+++ b/packages/common-i18n/src/locales/en/table.json
@@ -171,6 +171,8 @@
       "editField": "Edit Field",
       "insertField": "Insert Field",
       "graph": "Graph",
+      "defaultValue": "Default value",
+      "reset": "Reset",
       "fieldUpdated": "Field has been updated",
       "fieldCreated": "Field has been created",
       "previewDependenciesGraph": "Preview Dependencies Graph",
diff --git a/packages/common-i18n/src/locales/zh/table.json b/packages/common-i18n/src/locales/zh/table.json
index a04f8661b..f0bac3069 100644
--- a/packages/common-i18n/src/locales/zh/table.json
+++ b/packages/common-i18n/src/locales/zh/table.json
@@ -170,6 +170,8 @@
       "editField": "编辑字段",
       "insertField": "插入字段",
       "graph": "关系图",
+      "defaultValue": "默认值",
+      "reset": "清空",
       "fieldUpdated": "字段已更新",
       "fieldCreated": "字段已创建",
       "previewDependenciesGraph": "预览依赖关系图",
diff --git a/packages/core/src/models/field/derivate/abstract/select.field.abstract.ts b/packages/core/src/models/field/derivate/abstract/select.field.abstract.ts
index a55b8c91c..ba9dc94c9 100644
--- a/packages/core/src/models/field/derivate/abstract/select.field.abstract.ts
+++ b/packages/core/src/models/field/derivate/abstract/select.field.abstract.ts
@@ -15,10 +15,12 @@ export type ISelectFieldChoice = z.infer<typeof selectFieldChoiceSchema>;
 
 export const selectFieldOptionsSchema = z.object({
   choices: z.array(selectFieldChoiceSchema),
+  defaultValue: z.union([z.string(), z.array(z.string())]).optional(),
 });
 
 export const selectFieldOptionsRoSchema = z.object({
   choices: z.array(selectFieldChoiceRoSchema),
+  defaultValue: z.union([z.string(), z.array(z.string())]).optional(),
 });
 
 export type ISelectFieldOptions = z.infer<typeof selectFieldOptionsSchema>;
diff --git a/packages/core/src/models/field/derivate/abstract/user.field.abstract.ts b/packages/core/src/models/field/derivate/abstract/user.field.abstract.ts
index 075f61be0..ef4cbe3a3 100644
--- a/packages/core/src/models/field/derivate/abstract/user.field.abstract.ts
+++ b/packages/core/src/models/field/derivate/abstract/user.field.abstract.ts
@@ -37,7 +37,11 @@ export abstract class UserAbstractCore extends FieldCore {
 
   validateCellValue(cellValue: unknown) {
     if (this.isMultipleCellValue) {
-      return z.array(userCellValueSchema).nonempty().nullable().safeParse(cellValue);
+      return z
+        .array(userCellValueSchema)
+        .transform((arr) => (arr.length === 0 ? null : arr))
+        .nullable()
+        .safeParse(cellValue);
     }
     return userCellValueSchema.nullable().safeParse(cellValue);
   }
diff --git a/packages/core/src/models/field/derivate/checkbox.field.ts b/packages/core/src/models/field/derivate/checkbox.field.ts
index 607721e96..5d69aa3fb 100644
--- a/packages/core/src/models/field/derivate/checkbox.field.ts
+++ b/packages/core/src/models/field/derivate/checkbox.field.ts
@@ -2,7 +2,9 @@ import { z } from 'zod';
 import type { FieldType, CellValueType } from '../constant';
 import { FieldCore } from '../field';
 
-export const checkboxFieldOptionsSchema = z.object({}).strict();
+export const checkboxFieldOptionsSchema = z
+  .object({ defaultValue: z.boolean().optional() })
+  .strict();
 
 export type ICheckboxFieldOptions = z.infer<typeof checkboxFieldOptionsSchema>;
 
diff --git a/packages/core/src/models/field/derivate/long-text.field.ts b/packages/core/src/models/field/derivate/long-text.field.ts
index e8552d371..37c161874 100644
--- a/packages/core/src/models/field/derivate/long-text.field.ts
+++ b/packages/core/src/models/field/derivate/long-text.field.ts
@@ -2,7 +2,9 @@ import { z } from 'zod';
 import type { CellValueType, FieldType } from '../constant';
 import { FieldCore } from '../field';
 
-export const longTextFieldOptionsSchema = z.object({}).strict();
+export const longTextFieldOptionsSchema = z
+  .object({ defaultValue: z.string().optional() })
+  .strict();
 
 export type ILongTextFieldOptions = z.infer<typeof longTextFieldOptionsSchema>;
 
diff --git a/packages/core/src/models/field/derivate/number.field.ts b/packages/core/src/models/field/derivate/number.field.ts
index 6bd656772..b5ecd0326 100644
--- a/packages/core/src/models/field/derivate/number.field.ts
+++ b/packages/core/src/models/field/derivate/number.field.ts
@@ -12,6 +12,7 @@ import { getShowAsSchema, numberShowAsSchema } from '../show-as';
 export const numberFieldOptionsSchema = z.object({
   formatting: numberFormattingSchema,
   showAs: numberShowAsSchema.optional(),
+  defaultValue: z.number().optional(),
 });
 
 export const numberFieldOptionsRoSchema = numberFieldOptionsSchema.partial({
diff --git a/packages/core/src/models/field/derivate/single-line-text.field.ts b/packages/core/src/models/field/derivate/single-line-text.field.ts
index a8470acdf..cdd40ebc2 100644
--- a/packages/core/src/models/field/derivate/single-line-text.field.ts
+++ b/packages/core/src/models/field/derivate/single-line-text.field.ts
@@ -5,6 +5,7 @@ import { singleLineTextShowAsSchema } from '../show-as';
 
 export const singlelineTextFieldOptionsSchema = z.object({
   showAs: singleLineTextShowAsSchema.optional(),
+  defaultValue: z.string().optional(),
 });
 
 export type ISingleLineTextFieldOptions = z.infer<typeof singlelineTextFieldOptionsSchema>;
diff --git a/packages/core/src/models/field/derivate/user.field.ts b/packages/core/src/models/field/derivate/user.field.ts
index 073f8919c..f3ee0fa56 100644
--- a/packages/core/src/models/field/derivate/user.field.ts
+++ b/packages/core/src/models/field/derivate/user.field.ts
@@ -13,6 +13,11 @@ interface IContext {
   userSets?: IUser[];
 }
 
+const userIdSchema = z
+  .string()
+  .startsWith('usr')
+  .or(z.enum(['me']));
+
 export const userFieldOptionsSchema = z.object({
   isMultiple: z.boolean().optional().openapi({
     description: 'Allow adding multiple users',
@@ -20,6 +25,7 @@ export const userFieldOptionsSchema = z.object({
   shouldNotify: z.boolean().optional().openapi({
     description: 'Notify users when their name is added to a cell',
   }),
+  defaultValue: z.union([userIdSchema, z.array(userIdSchema)]).optional(),
 });
 
 export type IUserFieldOptions = z.infer<typeof userFieldOptionsSchema>;
diff --git a/packages/sdk/src/components/cell-value-editor/CellEditorMain.tsx b/packages/sdk/src/components/cell-value-editor/CellEditorMain.tsx
index 5198c6345..eec6bc9c0 100644
--- a/packages/sdk/src/components/cell-value-editor/CellEditorMain.tsx
+++ b/packages/sdk/src/components/cell-value-editor/CellEditorMain.tsx
@@ -120,7 +120,7 @@ export const CellEditorMain = (props: Omit<ICellValueEditor, 'wrapClassName' | '
           ref={editorRef}
           className={className}
           value={cellValue as ISingleSelectCellValue}
-          options={transformSelectOptions(options as ISelectFieldOptions)}
+          options={transformSelectOptions((options as ISelectFieldOptions).choices)}
           onChange={onChange}
           readonly={readonly}
           onOptionAdd={onOptionAdd}
@@ -133,7 +133,7 @@ export const CellEditorMain = (props: Omit<ICellValueEditor, 'wrapClassName' | '
           ref={editorRef}
           className={className}
           value={cellValue as IMultipleSelectCellValue}
-          options={transformSelectOptions(options as ISelectFieldOptions)}
+          options={transformSelectOptions((options as ISelectFieldOptions).choices)}
           onChange={onChange}
           isMultiple
           readonly={readonly}
diff --git a/packages/sdk/src/components/cell-value/CellValue.tsx b/packages/sdk/src/components/cell-value/CellValue.tsx
index 0eea36a23..1d79fbad2 100644
--- a/packages/sdk/src/components/cell-value/CellValue.tsx
+++ b/packages/sdk/src/components/cell-value/CellValue.tsx
@@ -69,7 +69,7 @@ export const CellValue = (props: ICellValueContainer) => {
       return (
         <CellSelect
           value={value as ISingleSelectCellValue | IMultipleSelectCellValue}
-          options={transformSelectOptions(options)}
+          options={transformSelectOptions(options.choices)}
           className={className}
           itemClassName={itemClassName}
           maxWidth={maxWidth}
diff --git a/packages/sdk/src/components/cell-value/cell-select/CellSelect.tsx b/packages/sdk/src/components/cell-value/cell-select/CellSelect.tsx
index 1a88c0f7e..5d04cdaa6 100644
--- a/packages/sdk/src/components/cell-value/cell-select/CellSelect.tsx
+++ b/packages/sdk/src/components/cell-value/cell-select/CellSelect.tsx
@@ -6,8 +6,8 @@ import { useMemo } from 'react';
 import type { ICellValue } from '../type';
 import { SelectTag } from './SelectTag';
 
-export const transformSelectOptions = (options: ISelectFieldOptions) => {
-  return options.choices.map(({ name, color }) => ({
+export const transformSelectOptions = (choices: ISelectFieldOptions['choices']) => {
+  return choices.map(({ name, color }) => ({
     label: name,
     value: name,
     color: ColorUtils.shouldUseLightTextOnColor(color) ? '#ffffff' : '#000000',
diff --git a/packages/sdk/src/components/editor/select/EditorMain.tsx b/packages/sdk/src/components/editor/select/EditorMain.tsx
index a32b20272..18268ad04 100644
--- a/packages/sdk/src/components/editor/select/EditorMain.tsx
+++ b/packages/sdk/src/components/editor/select/EditorMain.tsx
@@ -109,7 +109,7 @@ const SelectEditorMainBase: ForwardRefRenderFunction<
         }}
       />
       <OptionList options={filteredOptions} onSelect={onSelect} checkIsActive={checkIsActive} />
-      {(filteredOptions.length === 0 || optionAddable) && (
+      {onOptionAdd && (filteredOptions.length === 0 || optionAddable) && (
         <CommandItem
           className={cn('items-center justify-center', !optionAddable && 'opacity-0 h-0 p-0')}
           onSelect={onOptionAddInner}
diff --git a/packages/sdk/src/components/editor/user/EditorMain.tsx b/packages/sdk/src/components/editor/user/EditorMain.tsx
index 9035f3219..423d1b60b 100644
--- a/packages/sdk/src/components/editor/user/EditorMain.tsx
+++ b/packages/sdk/src/components/editor/user/EditorMain.tsx
@@ -5,6 +5,7 @@ import { getBaseCollaboratorList } from '@teable/openapi';
 import type { ForwardRefRenderFunction } from 'react';
 import React, { forwardRef } from 'react';
 import { ReactQueryKeys } from '../../../config';
+import { useTranslation } from '../../../context/app/i18n';
 import { useBaseId } from '../../../hooks';
 import type { ICellEditor, ICellEditorContext } from '../type';
 import type { IUserEditorRef } from './EditorBase';
@@ -12,24 +13,26 @@ import { UserEditorBase } from './EditorBase';
 
 export interface IUserEditorMainProps extends ICellEditor<IUserCellValue | IUserCellValue[]> {
   isMultiple?: boolean;
+  includeMe?: boolean;
   onChange?: (value?: IUserCellValue | IUserCellValue[]) => void;
   style?: React.CSSProperties;
   className?: string;
 }
 
 const DefaultDataWrapper = forwardRef<IUserEditorRef, IUserEditorMainProps>((props, ref) => {
+  const { t } = useTranslation();
   const baseId = useBaseId();
-  const { data: collaborators, isLoading } = useQuery({
+  const { data, isLoading } = useQuery({
     queryKey: ReactQueryKeys.baseCollaboratorList(baseId as string),
-    queryFn: ({ queryKey }) => getBaseCollaboratorList(queryKey[1]),
+    queryFn: ({ queryKey }) => getBaseCollaboratorList(queryKey[1]).then((res) => res.data),
   });
+
+  const collaborators = props.includeMe
+    ? [{ userId: 'me', userName: t('filter.currentUser'), email: '' }, ...(data || [])]
+    : data;
+
   return (
-    <UserEditorBase
-      {...props}
-      collaborators={collaborators?.data}
-      isLoading={isLoading}
-      ref={ref}
-    />
+    <UserEditorBase {...props} collaborators={collaborators} isLoading={isLoading} ref={ref} />
   );
 });