diff --git a/apps/web/.env.example b/apps/web/.env.example
index 40bbd45f..423421db 100644
--- a/apps/web/.env.example
+++ b/apps/web/.env.example
@@ -68,6 +68,7 @@ PGLITE_DB_PATH=/data/dory
 # ------------------------------
 # External Postgres (optional)
 # Uncomment if using Postgres instead of PGLite
+# Note: DB_TYPE=neon is not supported for app storage; Neon is only supported as an external connection type.
 # ------------------------------
 # DB_TYPE=postgres
 # DATABASE_URL="postgresql://user:password@host:5432/dbname"
diff --git a/apps/web/app/(app)/[organization]/[connectionId]/sql-console/components/sql-editor/use-sql-monaco-editor.ts b/apps/web/app/(app)/[organization]/[connectionId]/sql-console/components/sql-editor/use-sql-monaco-editor.ts
index 1336a9f7..3a8e0451 100644
--- a/apps/web/app/(app)/[organization]/[connectionId]/sql-console/components/sql-editor/use-sql-monaco-editor.ts
+++ b/apps/web/app/(app)/[organization]/[connectionId]/sql-console/components/sql-editor/use-sql-monaco-editor.ts
@@ -18,6 +18,7 @@ import { editorSelectionByTabAtom } from '../../sql-console.store';
 import { useTranslations } from 'next-intl';
 import type { ConnectionType } from '@/types/connections';
 import { getSqlDialectConfigForConnectionType, getSqlDialectParser, type SqlDialectParser } from '@/lib/sql/sql-dialect';
+import { isPostgresFamilyConnectionType } from '@/lib/connection/postgres-family';
 
 const MAX_SQL_LEN_FOR_PARSE = 20000;
 
@@ -140,7 +141,7 @@ const registerDtSqlCompletion = (
     getSchemas: () => any[],
     getActiveDatabase?: () => string,
 ) => {
-    const isPostgres = currentConnectionType === 'postgres';
+    const isPostgres = isPostgresFamilyConnectionType(currentConnectionType);
 
     return monaco.languages.registerCompletionItemProvider(languageId, {
         triggerCharacters: [' ', '.', ',', '(', '=', '\n'],
@@ -166,7 +167,6 @@ const registerDtSqlCompletion = (
             const offset = model.getOffsetAt(position);
             const prefixText = sql.slice(0, offset);
 
-            
             let suggestion: any = {};
             try {
                 suggestion = parser.getSuggestionAtCaretPosition?.(sql, caretPos) || {};
@@ -186,7 +186,6 @@ const registerDtSqlCompletion = (
             const syntaxList = Array.isArray(syntax) ? syntax : [];
             const columnPrefix = buildColumnPrefix(syntaxList, currentWord);
 
-            
             if (Array.isArray(keywords)) {
                 for (const kw of keywords) {
                     items.push({
@@ -205,7 +204,6 @@ const registerDtSqlCompletion = (
                 const hasTableContext = syntaxList.some(s => s.syntaxContextType === 'table');
                 const hasDatabaseContext = syntaxList.some(s => s.syntaxContextType === 'database' || s.syntaxContextType === 'databaseCreate');
 
-                
                 if (hasTableContext) {
                     const tableSyntax = syntaxList.find(s => s.syntaxContextType === 'table');
                     const typedTablePrefix =
@@ -258,7 +256,6 @@ const registerDtSqlCompletion = (
                         }
                     }
 
-                    
                     if (isPostgres) {
                         const normalizedSchemaPrefix = (qualifierPrefixRaw || typedTablePrefix || currentWord).toLowerCase();
 
@@ -338,34 +335,29 @@ const registerDtSqlCompletion = (
                     }
                 }
 
-                
                 if (hasColumnContext) {
-                    const rawPrefix = columnPrefix.trim(); 
+                    const rawPrefix = columnPrefix.trim();
                     let targetTables: string[] = [];
                     let filterPrefix = rawPrefix.toLowerCase();
 
-                    
                     const aliasMatch = rawPrefix.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\.(.*)$/);
                     if (aliasMatch) {
                         const aliasPart = aliasMatch[1]; // c
-                        const afterDotPart = aliasMatch[2]; 
+                        const afterDotPart = aliasMatch[2];
 
                         const tableFromAlias = resolveTableFromAliasInSql(sql, aliasPart);
                         if (tableFromAlias) {
                             targetTables = [tableFromAlias];
 
-                            
                             filterPrefix = (afterDotPart || '').toLowerCase();
                         }
                     }
 
-                    
                     if (!targetTables.length) {
                         const caretOffset = model.getOffsetAt(position);
                         targetTables = resolveTablesForColumnContext(parser, sql, caretPos, tables, caretOffset);
 
                         if (!targetTables.length) {
-                            
                             targetTables = tables.map(t => normalizeTableName(resolveTableName(t))).filter(Boolean);
                         }
                     }
@@ -428,7 +420,7 @@ export function useSqlMonacoEditor({
     const setSelectionByTab = useSetAtom(editorSelectionByTabAtom);
     const { databases } = useDatabases();
     const { tables } = useTables(activeDatabase);
-    const { schemas } = useSchemas(activeDatabase, currentConnectionType === 'postgres');
+    const { schemas } = useSchemas(activeDatabase, isPostgresFamilyConnectionType(currentConnectionType));
     const { refresh: refreshColumns } = useColumns();
     const refreshColumnsRef = useRef(refreshColumns);
     const t = useTranslations('SqlConsole');
@@ -497,7 +489,6 @@ export function useSqlMonacoEditor({
             const dialectConfig = getSqlDialectConfigForConnectionType(currentConnectionType);
             const languageId = dialectConfig.monacoLanguageId;
 
-            
             const parser = await getSqlDialectParser(dialectConfig.dialect);
             console.log(`[useSqlMonacoEditor] Loaded parser for dialect=${dialectConfig.dialect}`);
 
diff --git a/apps/web/app/(app)/[organization]/components/sql-console-sidebar/sidebar-config.ts b/apps/web/app/(app)/[organization]/components/sql-console-sidebar/sidebar-config.ts
index ac4822f3..c660bc51 100644
--- a/apps/web/app/(app)/[organization]/components/sql-console-sidebar/sidebar-config.ts
+++ b/apps/web/app/(app)/[organization]/components/sql-console-sidebar/sidebar-config.ts
@@ -1,5 +1,6 @@
 import type { ConnectionType } from '@/types/connections';
 import type { SidebarConfig } from './types';
+import { isPostgresFamilyConnectionType } from '@/lib/connection/postgres-family';
 
 const DEFAULT_CONFIG: SidebarConfig = {
     dialect: 'default',
@@ -28,6 +29,12 @@ const SIDEBAR_CONFIG_BY_DIALECT: Record<ConnectionType, SidebarConfig> = {
         supportsSchemas: false,
         hiddenDatabases: ['information_schema', 'mysql', 'performance_schema', 'sys'],
     },
+    neon: {
+        dialect: 'postgres',
+        supportsSchemas: true,
+        defaultSchemaName: 'public',
+        hiddenDatabases: ['system', 'information_schema'],
+    },
     postgres: {
         dialect: 'postgres',
         supportsSchemas: true,
@@ -46,5 +53,9 @@ export function getSidebarConfig(connectionType?: ConnectionType | null): Sideba
         return DEFAULT_CONFIG;
     }
 
+    if (isPostgresFamilyConnectionType(connectionType)) {
+        return SIDEBAR_CONFIG_BY_DIALECT.postgres;
+    }
+
     return SIDEBAR_CONFIG_BY_DIALECT[connectionType] ?? DEFAULT_CONFIG;
 }
diff --git a/apps/web/app/(app)/[organization]/components/table-browser/components/stats/index.tsx b/apps/web/app/(app)/[organization]/components/table-browser/components/stats/index.tsx
index 7d859785..7e011265 100644
--- a/apps/web/app/(app)/[organization]/components/table-browser/components/stats/index.tsx
+++ b/apps/web/app/(app)/[organization]/components/table-browser/components/stats/index.tsx
@@ -11,6 +11,7 @@ import { TableHealthReportCard } from './components/ai-insight';
 import PostgresTableStatsView from './postgres-stats';
 import { useTableStatsQuery } from '../table-queries';
 import { useTranslations } from 'next-intl';
+import { isPostgresFamilyConnectionType } from '@/lib/connection/postgres-family';
 // import TTLCard from './components/ttl-card';
 
 type TableStatsProps = {
@@ -28,9 +29,7 @@ function ClickhouseTableStatsView({ databaseName, tableName }: Omit<TableStatsPr
 
     const stats = statsQuery.data ?? null;
     const loading = statsQuery.isLoading;
-    const error =
-        (!connectionId && databaseName && tableName ? t('No available connection') : null) ||
-        (statsQuery.error ? (statsQuery.error as Error).message : null);
+    const error = (!connectionId && databaseName && tableName ? t('No available connection') : null) || (statsQuery.error ? (statsQuery.error as Error).message : null);
 
     if (!databaseName || !tableName) {
         return <div className="h-full flex items-center justify-center text-sm text-muted-foreground">{t('Select table to view stats')}</div>;
@@ -45,12 +44,7 @@ function ClickhouseTableStatsView({ databaseName, tableName }: Omit<TableStatsPr
                         <AlertDescription>{error}</AlertDescription>
                     </Alert>
                 ) : null}
-                <TableHealthReportCard
-                    tableStats={stats}
-                    databaseName={databaseName}
-                    tableName={tableName}
-                    connectionId={connectionId}
-                />
+                <TableHealthReportCard tableStats={stats} databaseName={databaseName} tableName={tableName} connectionId={connectionId} />
                 <SizeAndRowsCard stats={stats} loading={loading} />
                 <PartitionsCard stats={stats} loading={loading} />
                 <StorageHealthCard stats={stats} loading={loading} />
@@ -61,9 +55,8 @@ function ClickhouseTableStatsView({ databaseName, tableName }: Omit<TableStatsPr
 }
 
 export default function TableStatsView({ databaseName, tableName, driver }: TableStatsProps) {
-    if (driver === 'postgres') {
+    if (isPostgresFamilyConnectionType(driver)) {
         return <PostgresTableStatsView databaseName={databaseName} tableName={tableName} />;
     }
     return <ClickhouseTableStatsView databaseName={databaseName} tableName={tableName} />;
 }
-
diff --git a/apps/web/app/(app)/[organization]/components/table-browser/driver-table-browser.tsx b/apps/web/app/(app)/[organization]/components/table-browser/driver-table-browser.tsx
index d01d884c..014d03ed 100644
--- a/apps/web/app/(app)/[organization]/components/table-browser/driver-table-browser.tsx
+++ b/apps/web/app/(app)/[organization]/components/table-browser/driver-table-browser.tsx
@@ -3,7 +3,6 @@
 import { useEffect, useMemo, useState } from 'react';
 import { useTranslations } from 'next-intl';
 import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/registry/new-york-v4/ui/tabs';
-import type { ExplorerDriver } from '@/lib/explorer/types';
 import type { SQLTab } from '@/types/tabs';
 import { TableOverview } from './components/overview';
 import TableStats from './components/stats';
@@ -12,9 +11,10 @@ import TableDataPreview from './components/data-preview';
 import { TableIndexesTab } from './components/indexes';
 import { TableViewTabs } from './table-view-tabs';
 import type { TableSubTab } from './types';
+import { isPostgresFamilyConnectionType } from '@/lib/connection/postgres-family';
 
 type DriverTableBrowserProps = {
-    driver?: ExplorerDriver;
+    driver?: string;
     activeTab?: SQLTab;
     connectionId?: string;
     databaseName?: string;
@@ -27,8 +27,8 @@ type DriverTableBrowserProps = {
 const DEFAULT_TAB: TableSubTab = 'data';
 const POSTGRES_SUB_TABS: TableSubTab[] = ['overview', 'data', 'structure', 'stats', 'indexes'];
 
-function normalizeTab(driver: ExplorerDriver | undefined, tab?: TableSubTab): TableSubTab {
-    if (driver !== 'postgres' && tab === 'indexes') {
+function normalizeTab(driver: string | undefined, tab?: TableSubTab): TableSubTab {
+    if (!isPostgresFamilyConnectionType(driver) && tab === 'indexes') {
         return DEFAULT_TAB;
     }
 
@@ -60,7 +60,7 @@ export function DriverTableBrowser({
         onSubTabChange?.(next);
     };
 
-    if (driver !== 'postgres') {
+    if (!isPostgresFamilyConnectionType(driver)) {
         return (
             <div className="p-6 h-full flex flex-col">
                 <TableViewTabs
diff --git a/apps/web/app/(app)/[organization]/connections/api.ts b/apps/web/app/(app)/[organization]/connections/api.ts
index cdfa7be5..fd57f6e3 100644
--- a/apps/web/app/(app)/[organization]/connections/api.ts
+++ b/apps/web/app/(app)/[organization]/connections/api.ts
@@ -32,7 +32,6 @@ function translateConnectionsApi(key: string) {
 
 
 export async function addConnection(params: CreateConnectionPayload): Promise<ResponseObject<ConnectionListItem>> {
-    console.log('addConnection params:', params);
     const res = await fetchJsonResponse<ConnectionListItem>(
         '/api/connection',
         {
diff --git a/apps/web/app/(app)/[organization]/connections/components/connection-dialog.tsx b/apps/web/app/(app)/[organization]/connections/components/connection-dialog.tsx
index 285189f8..66d35207 100644
--- a/apps/web/app/(app)/[organization]/connections/components/connection-dialog.tsx
+++ b/apps/web/app/(app)/[organization]/connections/components/connection-dialog.tsx
@@ -27,6 +27,7 @@ import { ConnectionDialogFormSchema } from '../form-schema';
 import { useAtomValue } from 'jotai';
 import { currentConnectionAtom } from '@/shared/stores/app.store';
 import { getConnectionDriver } from './forms/connection/drivers';
+import { buildNeonConnectionStringForForm, normalizeNeonIdentityFromConnectionString } from './forms/connection/drivers/neon';
 
 type Mode = 'Create' | 'Edit';
 
@@ -62,6 +63,9 @@ export function ConnectionDialog({
     const { control, handleSubmit, reset } = form;
     const connectionType = useWatch({ control, name: 'connection.type' });
     const isSqlite = connectionType === 'sqlite';
+    const isNeon = connectionType === 'neon';
+    const hidesIdentityForm = isSqlite || isNeon;
+    const hidesSshForm = isSqlite || isNeon;
 
     const isEditMode = mode === 'Edit' && Boolean(connectionItem?.connection?.id);
 
@@ -82,6 +86,16 @@ export function ConnectionDialog({
     };
 
     const normalizeIdentityValues = (identityValues: any) => {
+        if (isNeon) {
+            const fallbackIdentity = connectionItem?.identities?.find((iden: any) => iden.isDefault);
+
+            return normalizeNeonIdentityFromConnectionString(form.getValues('connection.host'), {
+                id: fallbackIdentity?.id,
+                username: fallbackIdentity?.username,
+                database: fallbackIdentity?.database,
+            });
+        }
+
         if (!isSqlite) {
             return identityValues;
         }
@@ -112,21 +126,25 @@ export function ConnectionDialog({
                     ...formIdentity,
                 },
             } as any;
+            if (connectionItem.connection?.type === 'neon') {
+                nextValues.connection.host = buildNeonConnectionStringForForm(connectionItem.connection, formIdentity);
+            }
             reset(nextValues);
-            setSshOpen(Boolean((connectionItem as any).ssh?.enabled));
+            setSshOpen(connectionItem.connection?.type === 'neon' ? false : Boolean((connectionItem as any).ssh?.enabled));
         } else {
             reset(NEW_CONNECTION_DEFAULT_VALUES as any);
             setSshOpen(Boolean((NEW_CONNECTION_DEFAULT_VALUES as any).ssh?.enabled));
         }
     }, [open, isEditMode, connectionItem, reset]);
 
-    
     const onSaveSubmit = async (values: any) => {
         setSubmitting(true);
         try {
             const connectionId = connectionItem?.connection?.id;
             const defaultIdentity = connectionItem?.identities?.find((iden: any) => iden.isDefault);
-            const sshPayload = isSqlite ? null : normalizeSshValues(values.ssh, isEditMode ? connectionId : null);
+            const sshPayload = hidesSshForm
+                ? { enabled: false, host: null, port: null, username: null, authMethod: null }
+                : normalizeSshValues(values.ssh, isEditMode ? connectionId : null);
             const driver = getConnectionDriver(values.connection?.type);
             const normalizedConnection = driver.normalizeForSubmit(values.connection);
             const normalizedIdentity = normalizeIdentityValues(values.identity);
@@ -137,16 +155,16 @@ export function ConnectionDialog({
                 identities: [
                     isEditMode
                         ? {
-                            ...normalizedIdentity,
-                            id: normalizedIdentity?.id ?? defaultIdentity?.id,
-                        }
+                              ...normalizedIdentity,
+                              id: normalizedIdentity?.id ?? defaultIdentity?.id,
+                          }
                         : normalizedIdentity,
                 ],
             };
             console.log('onSaveSubmit values:', values, 'savedValues:', savedValues);
             if (isEditMode && connectionItem?.connection?.id) {
                 console.log('isEditMode true, updating connection');
-                
+
                 const updateValues: any = {
                     ...savedValues,
                     id: connectionItem.connection.id,
@@ -165,15 +183,14 @@ export function ConnectionDialog({
         }
     };
 
-    
     const onValidTest = async (values: any) => {
-        const sshPayload = isSqlite ? null : normalizeSshValues(values.ssh);
+        const sshPayload = hidesSshForm ? { enabled: false, host: null, port: null, username: null, authMethod: null } : normalizeSshValues(values.ssh);
         const driver = getConnectionDriver(values.connection?.type);
         const normalizedConnection = driver.normalizeForSubmit(values.connection);
         const normalizedIdentity = normalizeIdentityValues(values.identity);
         let testPayload = { ...values, ssh: sshPayload };
         if (mode === 'Edit') {
-            const mergedSsh = sshPayload ? { ...currentConnection?.ssh, ...sshPayload } : currentConnection?.ssh ?? null;
+            const mergedSsh = sshPayload ? { ...currentConnection?.ssh, ...sshPayload } : (currentConnection?.ssh ?? null);
             testPayload = {
                 connection: { ...currentConnection?.connection, ...normalizedConnection },
                 identity: { ...currentConnection?.identities?.find((iden: any) => iden.isDefault), ...normalizedIdentity },
@@ -192,13 +209,11 @@ export function ConnectionDialog({
         }
     };
 
-    
     const onInvalidTest = (errors: any) => {
         console.log('test connection validation errors:', errors);
         toast.error(t('Fix Form Errors Before Testing'));
     };
 
-    
     const handleTestConnection = () => {
         handleSubmit(onValidTest, onInvalidTest)();
     };
@@ -228,7 +243,6 @@ export function ConnectionDialog({
                     <form className="flex flex-col flex-1" onSubmit={handleSubmit(onSaveSubmit)}>
                         <ScrollArea className="overflow-hidden pr-2 h-[70vh]">
                             <div className="space-y-4 pb-4">
-                                
                                 <section className="rounded-xl border border-border/70 bg-background/80 p-4 space-y-4">
                                     <div className="flex items-center gap-2">
                                         <div className="flex h-7 w-7 items-center justify-center rounded-full bg-muted">
@@ -242,12 +256,12 @@ export function ConnectionDialog({
                                     <div className="space-y-4">
                                         <ConnectionForm form={form} />
 
-                                        {!isSqlite ? <p className="text-xs text-muted-foreground mt-3">{t('Authentication Info')}</p> : null}
-                                        {!isSqlite ? <IdentityForm form={form} /> : null}
+                                        {!hidesIdentityForm ? <p className="text-xs text-muted-foreground mt-3">{t('Authentication Info')}</p> : null}
+                                        {!hidesIdentityForm ? <IdentityForm form={form} /> : null}
                                     </div>
                                 </section>
 
-                                {!isSqlite ? (
+                                {!hidesSshForm ? (
                                     <section className="mt-2 rounded-xl border border-border/70 bg-background/80">
                                         <Collapsible open={sshOpen} onOpenChange={setSshOpen}>
                                             <div className="flex items-center justify-between px-4 py-3">
@@ -297,7 +311,6 @@ export function ConnectionDialog({
                             </div>
                         </ScrollArea>
 
-                        
                         <DialogFooter className="shrink-0 pt-4 mt-2 bg-background flex lg:justify-between">
                             <div>
                                 <Button type="button" onClick={handleTestConnection} disabled={submitting || testing} data-testid="test-connection">
diff --git a/apps/web/app/(app)/[organization]/connections/components/forms/connection/drivers/index.ts b/apps/web/app/(app)/[organization]/connections/components/forms/connection/drivers/index.ts
index 42c1420d..5229fd80 100644
--- a/apps/web/app/(app)/[organization]/connections/components/forms/connection/drivers/index.ts
+++ b/apps/web/app/(app)/[organization]/connections/components/forms/connection/drivers/index.ts
@@ -15,6 +15,7 @@ import {
     normalizeMariaDbConnectionForSubmit,
     validateMariaDbConnection,
 } from './mariadb';
+import { createNeonConnectionDefaults, NeonConnectionFields, normalizeNeonConnectionForForm, normalizeNeonConnectionForSubmit, validateNeonConnection } from './neon';
 import {
     PostgresConnectionFields,
     createPostgresConnectionDefaults,
@@ -23,15 +24,9 @@ import {
     validatePostgresConnection,
 } from './postgres';
 import { createMysqlConnectionDefaults, MysqlConnectionFields, normalizeMysqlConnectionForForm, normalizeMysqlConnectionForSubmit, validateMysqlConnection } from './mysql';
-import {
-    createSqliteConnectionDefaults,
-    normalizeSqliteConnectionForForm,
-    normalizeSqliteConnectionForSubmit,
-    SqliteConnectionFields,
-    validateSqliteConnection,
-} from './sqlite';
+import { createSqliteConnectionDefaults, normalizeSqliteConnectionForForm, normalizeSqliteConnectionForSubmit, SqliteConnectionFields, validateSqliteConnection } from './sqlite';
 
-export type SupportedConnectionDriver = 'clickhouse' | 'mariadb' | 'mysql' | 'postgres' | 'sqlite';
+export type SupportedConnectionDriver = 'clickhouse' | 'mariadb' | 'mysql' | 'neon' | 'postgres' | 'sqlite';
 
 type DriverDefinition = {
     label: string;
@@ -59,6 +54,14 @@ const DRIVERS: Record<SupportedConnectionDriver, DriverDefinition> = {
         normalizeForSubmit: normalizePostgresConnectionForSubmit,
         validate: validatePostgresConnection,
     },
+    neon: {
+        label: 'Neon',
+        FormComponent: NeonConnectionFields,
+        createDefaults: createNeonConnectionDefaults,
+        normalizeForForm: normalizeNeonConnectionForForm,
+        normalizeForSubmit: normalizeNeonConnectionForSubmit,
+        validate: validateNeonConnection,
+    },
     mariadb: {
         label: 'MariaDB',
         FormComponent: MariaDbConnectionFields,
@@ -100,6 +103,9 @@ export function getConnectionDriver(type?: string): DriverDefinition {
     if (type === 'postgres') {
         return DRIVERS.postgres;
     }
+    if (type === 'neon') {
+        return DRIVERS.neon;
+    }
     if (type === 'sqlite') {
         return DRIVERS.sqlite;
     }
diff --git a/apps/web/app/(app)/[organization]/connections/components/forms/connection/drivers/neon.tsx b/apps/web/app/(app)/[organization]/connections/components/forms/connection/drivers/neon.tsx
new file mode 100644
index 00000000..1b055b7a
--- /dev/null
+++ b/apps/web/app/(app)/[organization]/connections/components/forms/connection/drivers/neon.tsx
@@ -0,0 +1,223 @@
+import type { UseFormReturn } from 'react-hook-form';
+import { type RefinementCtx } from 'zod';
+import { FormControl, FormField, FormItem, FormLabel, FormMessage } from '@/registry/new-york-v4/ui/form';
+import { Input } from '@/registry/new-york-v4/ui/input';
+import { FieldHelp } from './shared';
+import { parsePostgresConnectionOptions, parsePostgresHostDraft } from './postgres';
+
+type ParsedNeonConnectionString = {
+    host?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    password?: string;
+    ssl: boolean;
+    searchParams: Record<string, string>;
+};
+
+function parseNeonConnectionString(rawValue: unknown): ParsedNeonConnectionString {
+    if (typeof rawValue !== 'string') {
+        return { ssl: true, searchParams: {} };
+    }
+
+    const trimmed = rawValue.trim();
+    if (!trimmed) {
+        return { ssl: true, searchParams: {} };
+    }
+
+    try {
+        const url = new URL(trimmed);
+        if (!/^postgres(ql)?:$/i.test(url.protocol)) {
+            return { ssl: true, searchParams: {} };
+        }
+
+        const hostname = url.hostname.includes(':') && !url.hostname.startsWith('[') ? `[${url.hostname}]` : url.hostname;
+        const sslMode = url.searchParams.get('sslmode')?.toLowerCase();
+        const searchParams = Object.fromEntries(url.searchParams.entries());
+
+        return {
+            host: hostname || undefined,
+            port: url.port ? Number(url.port) : undefined,
+            database: url.pathname ? decodeURIComponent(url.pathname.replace(/^\//, '')) || undefined : undefined,
+            username: url.username ? decodeURIComponent(url.username) : undefined,
+            password: url.password ? decodeURIComponent(url.password) : undefined,
+            ssl: sslMode ? sslMode !== 'disable' : true,
+            searchParams,
+        };
+    } catch {
+        return { ssl: true, searchParams: {} };
+    }
+}
+
+function buildNeonQueryString(options: Record<string, unknown>) {
+    const searchParams = new URLSearchParams();
+    const candidateKeys = ['sslmode', 'options', 'application_name', 'fallback_application_name', 'channel_binding'];
+
+    for (const key of candidateKeys) {
+        const value = options[key];
+        if (typeof value === 'string' && value.trim()) {
+            searchParams.set(key, value);
+        }
+    }
+
+    const queryString = searchParams.toString();
+    return queryString ? `?${queryString}` : '';
+}
+
+export function buildNeonConnectionStringForForm(connection: any, identity?: any) {
+    const options = parsePostgresConnectionOptions(connection?.options);
+    const storedConnectionString = typeof options.connectionString === 'string' ? options.connectionString.trim() : '';
+
+    if (storedConnectionString) {
+        return storedConnectionString;
+    }
+
+    const username = identity?.username?.trim?.();
+    const host = connection?.host?.trim?.();
+    const database = identity?.database?.trim?.() || connection?.database?.trim?.() || 'postgres';
+    const ssl = typeof options.ssl === 'boolean' ? options.ssl : typeof options.sslmode === 'string' ? options.sslmode !== 'disable' : true;
+
+    if (!host) {
+        return '';
+    }
+
+    const encodedUsername = username ? encodeURIComponent(username) : '';
+    const userInfo = encodedUsername ? `${encodedUsername}@` : '';
+    const port = typeof connection?.port === 'number' ? `:${connection.port}` : '';
+    if (!options.sslmode && ssl) {
+        options.sslmode = 'require';
+    }
+    if (!options.channel_binding) {
+        options.channel_binding = 'require';
+    }
+
+    const search = buildNeonQueryString(options);
+
+    return `postgresql://${userInfo}${host}${port}/${encodeURIComponent(database)}${search}`;
+}
+
+export function normalizeNeonIdentityFromConnectionString(
+    rawValue: unknown,
+    fallbackIdentity?: { id?: string | null; username?: string | null; password?: string | null; database?: string | null } | null,
+) {
+    const parsed = parseNeonConnectionString(rawValue);
+
+    return {
+        id: fallbackIdentity?.id ?? undefined,
+        name: 'Neon',
+        username: parsed.username ?? fallbackIdentity?.username ?? '',
+        role: null,
+        password: typeof parsed.password === 'string' && parsed.password.length > 0 ? parsed.password : undefined,
+        isDefault: true,
+        database: parsed.database ?? fallbackIdentity?.database ?? 'postgres',
+    };
+}
+
+export function createNeonConnectionDefaults() {
+    return {
+        type: 'neon',
+        name: '',
+        description: '',
+        host: '',
+        port: 5432,
+        httpPort: null,
+        ssl: true,
+        database: 'postgres',
+        environment: '',
+        tags: '',
+    };
+}
+
+export function normalizeNeonConnectionForForm(connection: any) {
+    const options = parsePostgresConnectionOptions(connection?.options);
+    const parsedHost = parsePostgresHostDraft(connection?.host);
+    const ssl = typeof options.ssl === 'boolean' ? options.ssl : typeof options.sslmode === 'string' ? options.sslmode !== 'disable' : true;
+
+    return {
+        ...createNeonConnectionDefaults(),
+        ...connection,
+        type: 'neon',
+        host: connection?.host ?? parsedHost.host ?? '',
+        port: typeof connection?.port === 'number' ? connection.port : (parsedHost.port ?? 5432),
+        httpPort: null,
+        ssl,
+        database: connection?.database ?? parsedHost.database ?? 'postgres',
+    };
+}
+
+export function normalizeNeonConnectionForSubmit(connection: any) {
+    const options = parsePostgresConnectionOptions(connection?.options);
+    const { ssl: _ssl, ...restConnection } = connection ?? {};
+    const connectionString = connection?.host?.trim?.() ?? '';
+    const parsedConnectionString = parseNeonConnectionString(connection?.host);
+    const parsedHost = parsePostgresHostDraft(connection?.host);
+
+    options.ssl = parsedConnectionString.ssl;
+    options.sslmode = parsedConnectionString.ssl ? 'require' : 'disable';
+    Object.assign(options, parsedConnectionString.searchParams);
+    options.connectionString = connectionString;
+    if (!options.channel_binding) {
+        options.channel_binding = 'require';
+    }
+    delete options.useSSL;
+    delete options.protocol;
+    delete options.httpPort;
+
+    return {
+        ...restConnection,
+        type: 'neon',
+        host: parsedConnectionString.host ?? parsedHost.host ?? connection?.host?.trim?.() ?? '',
+        port: typeof connection?.port === 'number' && Number.isFinite(connection.port) ? connection.port : (parsedConnectionString.port ?? parsedHost.port ?? 5432),
+        httpPort: null,
+        database: (parsedConnectionString.database ?? connection?.database?.trim?.()) || parsedHost.database || 'postgres',
+        options: JSON.stringify(options),
+    };
+}
+
+export function validateNeonConnection(value: any, ctx: RefinementCtx) {
+    const rawConnectionString = value?.host?.trim?.() ?? '';
+
+    if (!rawConnectionString) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['host'],
+            message: 'Please provide a Neon connection string',
+        });
+        return;
+    }
+
+    const parsed = parseNeonConnectionString(rawConnectionString);
+
+    if (!parsed.host || !parsed.username) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['host'],
+            message: 'Please paste a valid Neon PostgreSQL connection string',
+        });
+    }
+}
+
+export function NeonConnectionFields({ form }: { form: UseFormReturn<any> }) {
+    return (
+        <div className="space-y-4">
+            <FormField
+                control={form.control}
+                name="connection.host"
+                render={({ field }) => (
+                    <FormItem className="space-y-2">
+                        <FormLabel className="flex items-center gap-1.5">
+                            <span>
+                                Connection String<span className="text-destructive"> *</span>
+                            </span>
+                            <FieldHelp text="Paste the Neon PostgreSQL connection string. Username, password, host, port, database, and SSL are parsed automatically." />
+                        </FormLabel>
+                        <FormControl>
+                            <Input placeholder="postgresql://user:password@ep-xxxx-pooler.us-east-1.aws.neon.tech/dbname?sslmode=require" {...field} value={field.value ?? ''} />
+                        </FormControl>
+                        <FormMessage />
+                    </FormItem>
+                )}
+            />
+        </div>
+    );
+}
diff --git a/apps/web/app/(app)/[organization]/connections/components/forms/connection/drivers/postgres.tsx b/apps/web/app/(app)/[organization]/connections/components/forms/connection/drivers/postgres.tsx
index 1506d32b..19fc827e 100644
--- a/apps/web/app/(app)/[organization]/connections/components/forms/connection/drivers/postgres.tsx
+++ b/apps/web/app/(app)/[organization]/connections/components/forms/connection/drivers/postgres.tsx
@@ -5,7 +5,7 @@ import { Input } from '@/registry/new-york-v4/ui/input';
 import { Switch } from '@/registry/new-york-v4/ui/switch';
 import { FieldHelp, PortField } from './shared';
 
-function parsePostgresHostDraft(rawHost: unknown): { host?: string; port?: number; database?: string } {
+export function parsePostgresHostDraft(rawHost: unknown): { host?: string; port?: number; database?: string } {
     if (typeof rawHost !== 'string') return {};
     const trimmed = rawHost.trim();
     if (!trimmed) return {};
@@ -26,7 +26,7 @@ function parsePostgresHostDraft(rawHost: unknown): { host?: string; port?: numbe
     }
 }
 
-function parseConnectionOptions(raw: unknown): Record<string, unknown> {
+export function parsePostgresConnectionOptions(raw: unknown): Record<string, unknown> {
     if (!raw) return {};
     if (typeof raw === 'object' && !Array.isArray(raw)) return { ...(raw as Record<string, unknown>) };
     if (typeof raw === 'string') {
@@ -58,20 +58,15 @@ export function createPostgresConnectionDefaults() {
 }
 
 export function normalizePostgresConnectionForForm(connection: any) {
-    const options = parseConnectionOptions(connection?.options);
+    const options = parsePostgresConnectionOptions(connection?.options);
     const parsedHost = parsePostgresHostDraft(connection?.host);
-    const ssl =
-        typeof options.ssl === 'boolean'
-            ? options.ssl
-            : typeof options.sslmode === 'string'
-              ? options.sslmode !== 'disable'
-              : false;
+    const ssl = typeof options.ssl === 'boolean' ? options.ssl : typeof options.sslmode === 'string' ? options.sslmode !== 'disable' : false;
 
     return {
         ...createPostgresConnectionDefaults(),
         ...connection,
         host: parsedHost.host ?? connection?.host ?? '',
-        port: typeof connection?.port === 'number' ? connection.port : parsedHost.port ?? 5432,
+        port: typeof connection?.port === 'number' ? connection.port : (parsedHost.port ?? 5432),
         httpPort: null,
         ssl,
         database: connection?.database ?? parsedHost.database ?? 'postgres',
@@ -79,7 +74,7 @@ export function normalizePostgresConnectionForForm(connection: any) {
 }
 
 export function normalizePostgresConnectionForSubmit(connection: any) {
-    const options = parseConnectionOptions(connection?.options);
+    const options = parsePostgresConnectionOptions(connection?.options);
     const { ssl: _ssl, ...restConnection } = connection ?? {};
     const parsedHost = parsePostgresHostDraft(connection?.host);
     const ssl = Boolean(connection?.ssl);
@@ -97,10 +92,7 @@ export function normalizePostgresConnectionForSubmit(connection: any) {
     return {
         ...restConnection,
         host: parsedHost.host ?? connection?.host?.trim?.() ?? '',
-        port:
-            typeof connection?.port === 'number' && Number.isFinite(connection.port)
-                ? connection.port
-                : parsedHost.port ?? 5432,
+        port: typeof connection?.port === 'number' && Number.isFinite(connection.port) ? connection.port : (parsedHost.port ?? 5432),
         httpPort: null,
         database: connection?.database?.trim?.() || parsedHost.database || 'postgres',
         options: JSON.stringify(options),
@@ -119,7 +111,9 @@ export function PostgresConnectionFields({ form }: { form: UseFormReturn<any> })
                     render={({ field }) => (
                         <FormItem className="space-y-2">
                             <FormLabel className="flex items-center gap-1.5">
-                                <span>Host<span className="text-destructive"> *</span></span>
+                                <span>
+                                    Host<span className="text-destructive"> *</span>
+                                </span>
                                 <FieldHelp text="Use your PostgreSQL server hostname or IP address." />
                             </FormLabel>
                             <FormControl>
diff --git a/apps/web/app/(app)/[organization]/connections/form-schema.ts b/apps/web/app/(app)/[organization]/connections/form-schema.ts
index a28bad49..ac210cb1 100644
--- a/apps/web/app/(app)/[organization]/connections/form-schema.ts
+++ b/apps/web/app/(app)/[organization]/connections/form-schema.ts
@@ -14,80 +14,93 @@ function isAbsolutePath(value: string) {
     return /^(\/|[a-zA-Z]:[\\/])/.test(value);
 }
 
-export const ConnectionDialogFormSchema = z.object({
-    connection: z.object({
-        type: z.string().min(1, 'Please select a connection type'),
-        name: z.string().min(1, 'Please provide a connection name'),
-        description: z.string().optional().nullable(),
-        host: z.string().optional().nullable(),
-        port: requiredPort.optional().nullable(),
-        httpPort: requiredPort.optional().nullable(),
-        ssl: z.boolean().default(false),
-        database: z.string().optional().nullable(),
-        path: z.string().optional().nullable(),
-        environment: z.string().optional(),
-        tags: z.string().optional(),
-    }),
-    identity: z.object({
-        name: z.string().optional(),
-        username: z.string().optional().nullable(),
-        role: z.string().optional().nullable(),
-        password: z.string().optional().nullable(),
-        isDefault: z.boolean().optional(),
-    }),
-    ssh: z.object({
-        enabled: z.boolean().optional(),
-        host: z.string().optional().nullable(),
-        port: z.number().optional().nullable(),
-        username: z.string().optional().nullable(),
-        authMethod: z.string().optional().nullable(),
-        password: z.string().optional().nullable(),
-        privateKey: z.string().optional().nullable(),
-        passphrase: z.string().optional().nullable(),
-    }),
-}).superRefine((value, ctx) => {
-    const driver = getConnectionDriver(value.connection.type);
-    driver.validate(value.connection, ctx);
+export const ConnectionDialogFormSchema = z
+    .object({
+        connection: z.object({
+            type: z.string().min(1, 'Please select a connection type'),
+            name: z.string().min(1, 'Please provide a connection name'),
+            description: z.string().optional().nullable(),
+            host: z.string().optional().nullable(),
+            port: requiredPort.optional().nullable(),
+            httpPort: requiredPort.optional().nullable(),
+            ssl: z.boolean().default(false),
+            database: z.string().optional().nullable(),
+            path: z.string().optional().nullable(),
+            environment: z.string().optional(),
+            tags: z.string().optional(),
+        }),
+        identity: z.object({
+            name: z.string().optional(),
+            username: z.string().optional().nullable(),
+            role: z.string().optional().nullable(),
+            password: z.string().optional().nullable(),
+            isDefault: z.boolean().optional(),
+        }),
+        ssh: z.object({
+            enabled: z.boolean().optional(),
+            host: z.string().optional().nullable(),
+            port: z.number().optional().nullable(),
+            username: z.string().optional().nullable(),
+            authMethod: z.string().optional().nullable(),
+            password: z.string().optional().nullable(),
+            privateKey: z.string().optional().nullable(),
+            passphrase: z.string().optional().nullable(),
+        }),
+    })
+    .superRefine((value, ctx) => {
+        const driver = getConnectionDriver(value.connection.type);
+        driver.validate(value.connection, ctx);
 
-    if (value.connection.type === 'sqlite') {
-        const normalizedPath = value.connection.path?.trim() ?? '';
-        if (!normalizedPath) {
+        if (value.connection.type === 'sqlite') {
+            const normalizedPath = value.connection.path?.trim() ?? '';
+            if (!normalizedPath) {
+                ctx.addIssue({
+                    code: 'custom',
+                    path: ['connection', 'path'],
+                    message: 'Please provide a SQLite file path',
+                });
+            } else if (!isAbsolutePath(normalizedPath)) {
+                ctx.addIssue({
+                    code: 'custom',
+                    path: ['connection', 'path'],
+                    message: 'SQLite path must be absolute',
+                });
+            }
+            return;
+        }
+
+        if (value.connection.type === 'neon') {
+            if (!value.connection.host?.trim()) {
+                ctx.addIssue({
+                    code: 'custom',
+                    path: ['connection', 'host'],
+                    message: 'Please provide a Neon connection string',
+                });
+            }
+            return;
+        }
+
+        if (!value.connection.host?.trim()) {
             ctx.addIssue({
                 code: 'custom',
-                path: ['connection', 'path'],
-                message: 'Please provide a SQLite file path',
+                path: ['connection', 'host'],
+                message: 'Please provide a host',
             });
-        } else if (!isAbsolutePath(normalizedPath)) {
+        }
+
+        if (typeof value.connection.port !== 'number' || !Number.isFinite(value.connection.port)) {
             ctx.addIssue({
                 code: 'custom',
-                path: ['connection', 'path'],
-                message: 'SQLite path must be absolute',
+                path: ['connection', 'port'],
+                message: 'Please provide a port number',
             });
         }
-        return;
-    }
 
-    if (!value.connection.host?.trim()) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['connection', 'host'],
-            message: 'Please provide a host',
-        });
-    }
-
-    if (typeof value.connection.port !== 'number' || !Number.isFinite(value.connection.port)) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['connection', 'port'],
-            message: 'Please provide a port number',
-        });
-    }
-
-    if (!value.identity.username?.trim()) {
-        ctx.addIssue({
-            code: 'custom',
-            path: ['identity', 'username'],
-            message: 'Please provide a username',
-        });
-    }
-});
+        if (!value.identity.username?.trim()) {
+            ctx.addIssue({
+                code: 'custom',
+                path: ['identity', 'username'],
+                message: 'Please provide a username',
+            });
+        }
+    });
diff --git a/apps/web/app/api/connection/[id]/databases/[database]/summary/route.ts b/apps/web/app/api/connection/[id]/databases/[database]/summary/route.ts
index 3645b82a..c5d48dc8 100644
--- a/apps/web/app/api/connection/[id]/databases/[database]/summary/route.ts
+++ b/apps/web/app/api/connection/[id]/databases/[database]/summary/route.ts
@@ -7,6 +7,7 @@ import { hasMetadataCapability } from '@/lib/connection/base/types';
 import { ensureConnectionPoolForUser, mapConnectionErrorToResponse } from '@/app/api/connection/utils';
 import { withUserAndOrganizationHandler } from '@/app/api/utils/with-organization-handler';
 import { getApiLocale, translateApi } from '@/app/api/utils/i18n';
+import { isPostgresFamilyConnectionType } from '@/lib/connection/postgres-family';
 
 const paramsSchema = z.object({
     database: z.string().min(1),
@@ -159,7 +160,9 @@ export async function GET(req: NextRequest, context: { params: Promise<{ databas
 
         try {
             const { entry, config } = await ensureConnectionPoolForUser(userId, organizationId, connectionId, null);
-            const engine = (config.type ?? 'unknown') as 'clickhouse' | 'doris' | 'mariadb' | 'mysql' | 'postgres' | 'sqlite' | 'unknown';
+            const engine = isPostgresFamilyConnectionType(config.type)
+                ? 'postgres'
+                : ((config.type ?? 'unknown') as 'clickhouse' | 'doris' | 'mariadb' | 'mysql' | 'postgres' | 'sqlite' | 'unknown');
             const cluster = config.port ? `${config.host}:${config.port}` : (config.host ?? null);
             const metadata = entry.instance.capabilities.metadata;
             if (!hasMetadataCapability(metadata, 'getDatabaseSummary')) {
diff --git a/apps/web/app/api/connection/test/service.ts b/apps/web/app/api/connection/test/service.ts
index 512031b1..78cf5a2d 100644
--- a/apps/web/app/api/connection/test/service.ts
+++ b/apps/web/app/api/connection/test/service.ts
@@ -21,7 +21,6 @@ function hasSshSecret(ssh?: SSHConfigWithSecrets | null): boolean {
     return values.length > 0;
 }
 
-
 export async function testConnectService(organizationId: string, payload: TestConnectionPayload): Promise<HealthInfo> {
     const db = await getDBService();
     const connectionId = payload.connection?.id;
@@ -44,9 +43,8 @@ export async function testConnectService(organizationId: string, payload: TestCo
 
     const testPassword = payload?.identity?.password ?? plainPassword;
     const resolvedSsh = await resolveSshSecrets(organizationId, payload, db);
-    const config = buildTestConnectionConfig(
-        { ...payload, identity: { ...payload.identity, password: testPassword }, ssh: resolvedSsh },
-        code => createConnectionError(code as ConnectionErrorCode),
+    const config = buildTestConnectionConfig({ ...payload, identity: { ...payload.identity, password: testPassword }, ssh: resolvedSsh }, code =>
+        createConnectionError(code as ConnectionErrorCode),
     );
     let provider = null as Awaited<ReturnType<typeof createProvider>> | null;
 
diff --git a/apps/web/lib/connection/base/types.ts b/apps/web/lib/connection/base/types.ts
index ed1fa781..70eb1071 100644
--- a/apps/web/lib/connection/base/types.ts
+++ b/apps/web/lib/connection/base/types.ts
@@ -1,7 +1,7 @@
 import { QueryInsightsFilters, QueryInsightsSummary, QueryTimelinePoint, QueryInsightsRow } from '@/types/monitoring';
 import { TableIndexInfo, TablePropertiesRow, TableStats } from '@/types/table-info';
 
-export type ConnectionType = 'clickhouse' | 'mariadb' | 'mysql' | 'postgres' | 'sqlite';
+export type ConnectionType = 'clickhouse' | 'mariadb' | 'mysql' | 'neon' | 'postgres' | 'sqlite';
 
 export interface BaseConfig {
     id: string; // datasource_id
diff --git a/apps/web/lib/connection/drivers/postgres/PostgresDatasource.ts b/apps/web/lib/connection/drivers/postgres/PostgresDatasource.ts
index 480c94ce..009ab147 100644
--- a/apps/web/lib/connection/drivers/postgres/PostgresDatasource.ts
+++ b/apps/web/lib/connection/drivers/postgres/PostgresDatasource.ts
@@ -90,10 +90,7 @@ export class PostgresDatasource extends BaseConnection {
         });
     }
 
-    async queryWithContext<Row = any>(
-        sql: string,
-        context?: ConnectionQueryContext & { params?: DriverQueryParams },
-    ): Promise<QueryResult<Row>> {
+    async queryWithContext<Row = any>(sql: string, context?: ConnectionQueryContext & { params?: DriverQueryParams }): Promise<QueryResult<Row>> {
         this.assertReady();
         const targetDatabase = context?.database ?? this.config.database;
         const pool = this.resolvePool(targetDatabase);
diff --git a/apps/web/lib/connection/drivers/postgres/postgres-driver.ts b/apps/web/lib/connection/drivers/postgres/postgres-driver.ts
index a2bfa517..e0d614e7 100644
--- a/apps/web/lib/connection/drivers/postgres/postgres-driver.ts
+++ b/apps/web/lib/connection/drivers/postgres/postgres-driver.ts
@@ -15,6 +15,8 @@ type PostgresRuntimeOptions = {
     statementTimeoutMs?: number;
     connectionTimeoutMs?: number;
     applicationName?: string;
+    connectionOptions?: string;
+    enableChannelBinding?: boolean;
 };
 
 type PostgresConnectionOverride = {
@@ -84,6 +86,41 @@ function parsePositiveInt(value: unknown): number | undefined {
     return undefined;
 }
 
+function mergeConnectionStringWithConfig(connectionString: string, config: BaseConfig, databaseOverride?: string, connectionOverride?: PostgresConnectionOverride) {
+    try {
+        const url = new URL(connectionString);
+        if (!/^postgres(ql)?:$/i.test(url.protocol)) {
+            return connectionString;
+        }
+
+        const resolvedHost = connectionOverride?.host ?? config.host;
+        const resolvedPort = connectionOverride?.port ?? normalizePort(config.port);
+        const resolvedDatabase = databaseOverride ?? config.database;
+        const resolvedUsername = config.username;
+        const resolvedPassword = config.password;
+
+        if (resolvedHost) {
+            url.hostname = resolvedHost.replace(/^\[(.*)\]$/, '$1');
+        }
+        if (resolvedPort) {
+            url.port = String(resolvedPort);
+        }
+        if (resolvedDatabase) {
+            url.pathname = `/${encodeURIComponent(resolvedDatabase)}`;
+        }
+        if (resolvedUsername && !url.username) {
+            url.username = encodeURIComponent(resolvedUsername);
+        }
+        if (resolvedPassword && !url.password) {
+            url.password = encodeURIComponent(resolvedPassword);
+        }
+
+        return url.toString();
+    } catch {
+        return connectionString;
+    }
+}
+
 function extractRuntimeOptions(config: BaseConfig): PostgresRuntimeOptions {
     const options = (config.options ?? {}) as Record<string, unknown>;
     const sslMode = typeof options.sslmode === 'string' ? options.sslmode.toLowerCase() : undefined;
@@ -104,10 +141,12 @@ function extractRuntimeOptions(config: BaseConfig): PostgresRuntimeOptions {
         queryTimeoutMs: parsePositiveInt(options.request_timeout),
         statementTimeoutMs: parsePositiveInt(options.statement_timeout),
         connectionTimeoutMs: parsePositiveInt(options.connection_timeout),
-        applicationName:
-            typeof options.application_name === 'string' && options.application_name.trim()
-                ? options.application_name.trim()
-                : 'dory',
+        applicationName: typeof options.application_name === 'string' && options.application_name.trim() ? options.application_name.trim() : 'dory',
+        connectionOptions: typeof options.options === 'string' && options.options.trim() ? options.options.trim() : undefined,
+        enableChannelBinding:
+            typeof options.channel_binding === 'string'
+                ? options.channel_binding.toLowerCase() === 'require'
+                : Boolean((options as { enableChannelBinding?: unknown }).enableChannelBinding),
     };
 }
 
@@ -116,15 +155,14 @@ export function resolvePostgresPort(config: BaseConfig): number {
     return hostConfig.port ?? 5432;
 }
 
-function buildPoolConfig(
-    config: BaseConfig,
-    databaseOverride?: string,
-    connectionOverride?: PostgresConnectionOverride,
-): PoolConfig {
+export function buildPostgresPoolConfig(config: BaseConfig, databaseOverride?: string, connectionOverride?: PostgresConnectionOverride): PoolConfig {
     const hostConfig = parseHostInput(config.host, config.port);
     const runtime = extractRuntimeOptions(config);
+    const rawOptions = (config.options ?? {}) as Record<string, unknown>;
+    const connectionString =
+        config.type === 'neon' && typeof rawOptions.connectionString === 'string' && rawOptions.connectionString.trim() ? rawOptions.connectionString.trim() : undefined;
 
-    return {
+    const poolConfig = {
         host: connectionOverride?.host ?? hostConfig.host,
         port: connectionOverride?.port ?? hostConfig.port ?? 5432,
         user: config.username ?? hostConfig.user,
@@ -137,7 +175,15 @@ function buildPoolConfig(
         query_timeout: runtime.queryTimeoutMs,
         statement_timeout: runtime.statementTimeoutMs,
         application_name: runtime.applicationName,
-    };
+        options: runtime.connectionOptions,
+        ...(runtime.enableChannelBinding ? ({ enableChannelBinding: true } as any) : {}),
+    } as PoolConfig;
+
+    if (connectionString) {
+        poolConfig.connectionString = mergeConnectionStringWithConfig(connectionString, config, databaseOverride, connectionOverride);
+    }
+
+    return poolConfig;
 }
 
 function normalizeColumns(result: PgResult<any>) {
@@ -188,12 +234,8 @@ function quoteQualifiedPath(input: string): string {
         .join(', ');
 }
 
-export function createPostgresPool(
-    config: BaseConfig,
-    databaseOverride?: string,
-    connectionOverride?: PostgresConnectionOverride,
-): Pool {
-    return new Pool(buildPoolConfig(config, databaseOverride, connectionOverride));
+export function createPostgresPool(config: BaseConfig, databaseOverride?: string, connectionOverride?: PostgresConnectionOverride): Pool {
+    return new Pool(buildPostgresPoolConfig(config, databaseOverride, connectionOverride));
 }
 
 export async function pingPostgres(pool: Pool): Promise<HealthInfo & { version?: string }> {
@@ -207,13 +249,7 @@ export async function pingPostgres(pool: Pool): Promise<HealthInfo & { version?:
     };
 }
 
-export async function executePostgresQuery<Row>(
-    pool: Pool,
-    config: BaseConfig,
-    sql: string,
-    params?: DriverQueryParams,
-    options?: QuerySessionOptions,
-): Promise<QueryResult<Row>> {
+export async function executePostgresQuery<Row>(pool: Pool, config: BaseConfig, sql: string, params?: DriverQueryParams, options?: QuerySessionOptions): Promise<QueryResult<Row>> {
     const { sql: compiledSql, values } = normalizeParams(sql, params);
     const client = (await pool.connect()) as PgClientLike;
     const started = Date.now();
@@ -233,10 +269,7 @@ export async function executePostgresQuery<Row>(
             rows: (Array.isArray(result.rows) ? result.rows : []) as Row[],
             rowCount: typeof result.rowCount === 'number' ? result.rowCount : undefined,
             columns: normalizeColumns(result),
-            limited:
-                typeof result.rowCount === 'number' &&
-                /^\s*(select|with)\b/i.test(compiledSql) &&
-                result.rowCount >= MAX_RESULT_ROWS,
+            limited: typeof result.rowCount === 'number' && /^\s*(select|with)\b/i.test(compiledSql) && result.rowCount >= MAX_RESULT_ROWS,
             limit: /^\s*(select|with)\b/i.test(compiledSql) ? MAX_RESULT_ROWS : undefined,
             tookMs: Date.now() - started,
         };
@@ -246,13 +279,7 @@ export async function executePostgresQuery<Row>(
     }
 }
 
-export async function executePostgresCommand(
-    pool: Pool,
-    config: BaseConfig,
-    sql: string,
-    params?: DriverQueryParams,
-    context?: ConnectionQueryContext,
-): Promise<void> {
+export async function executePostgresCommand(pool: Pool, config: BaseConfig, sql: string, params?: DriverQueryParams, context?: ConnectionQueryContext): Promise<void> {
     await executePostgresQuery(pool, config, sql, params, { context });
 }
 
diff --git a/apps/web/lib/connection/postgres-family.ts b/apps/web/lib/connection/postgres-family.ts
new file mode 100644
index 00000000..4049499b
--- /dev/null
+++ b/apps/web/lib/connection/postgres-family.ts
@@ -0,0 +1,11 @@
+import type { ConnectionType } from '@/types/connections';
+
+export type PostgresFamilyConnectionType = 'postgres' | 'neon';
+
+export function isPostgresFamilyConnectionType(value?: string | null): value is PostgresFamilyConnectionType {
+    return value === 'postgres' || value === 'neon';
+}
+
+export function normalizePostgresFamilyConnectionType(value?: string | null): ConnectionType | 'unknown' {
+    return isPostgresFamilyConnectionType(value) ? 'postgres' : ((value ?? 'unknown') as ConnectionType | 'unknown');
+}
diff --git a/apps/web/lib/connection/registry/index.ts b/apps/web/lib/connection/registry/index.ts
index 3f98f5f1..0ed5f68a 100644
--- a/apps/web/lib/connection/registry/index.ts
+++ b/apps/web/lib/connection/registry/index.ts
@@ -11,6 +11,7 @@ const registry = new Map<ConnectionType, ConnectionDriverCtor>();
 registry.set('clickhouse', ClickhouseDatasource);
 registry.set('mariadb', MariaDbDatasource);
 registry.set('mysql', MySqlDatasource);
+registry.set('neon', PostgresDatasource);
 registry.set('postgres', PostgresDatasource);
 registry.set('sqlite', SqliteDatasource);
 
diff --git a/apps/web/lib/connection/registry/types.ts b/apps/web/lib/connection/registry/types.ts
index 16592498..5230a397 100644
--- a/apps/web/lib/connection/registry/types.ts
+++ b/apps/web/lib/connection/registry/types.ts
@@ -16,5 +16,5 @@ export type ConnectionParameterDialect =
 export type ConnectionDriverCtor = new (config: BaseConfig) => BaseConnection;
 
 export function isConnectionDriverType(value: unknown): value is ConnectionDriverType {
-    return value === 'clickhouse' || value === 'mariadb' || value === 'mysql' || value === 'postgres' || value === 'sqlite';
+    return value === 'clickhouse' || value === 'mariadb' || value === 'mysql' || value === 'neon' || value === 'postgres' || value === 'sqlite';
 }
diff --git a/apps/web/lib/database/postgres/impl/connections/index.ts b/apps/web/lib/database/postgres/impl/connections/index.ts
index 6c518d44..b3675e9f 100644
--- a/apps/web/lib/database/postgres/impl/connections/index.ts
+++ b/apps/web/lib/database/postgres/impl/connections/index.ts
@@ -58,9 +58,7 @@ export class PostgresConnectionsRepository {
 
             if (isDesktopRuntime()) {
                 try {
-                    await this.db.execute(
-                        sql`ALTER TABLE "connections" DROP CONSTRAINT IF EXISTS "connections_created_by_user_id_user_id_fk"`,
-                    );
+                    await this.db.execute(sql`ALTER TABLE "connections" DROP CONSTRAINT IF EXISTS "connections_created_by_user_id_user_id_fk"`);
                 } catch (error) {
                     console.warn('[db:init] skipped legacy desktop constraint cleanup:', error);
                 }
@@ -247,7 +245,7 @@ export class PostgresConnectionsRepository {
                             secret: {
                                 passwordEncrypted,
                             },
-                        }
+                        };
                         await this.createIdentityWithSecret(tx, userId, created.organizationId, created.id, savedIdentityWithSecret as any);
                     }
                 }
@@ -270,6 +268,10 @@ export class PostgresConnectionsRepository {
             delete connectionPayload.id;
         }
 
+        if (connectionPayload.type) {
+            connectionPayload.engine = getDBEngineViaType(connectionPayload.type);
+        }
+
         const [updatedConnection] = await this.db
             .update(connections)
             .set(connectionPayload)
@@ -288,14 +290,11 @@ export class PostgresConnectionsRepository {
         if (payload.identities && payload.identities.length > 0) {
             for (const identity of payload.identities as any) {
                 if (!identity.id) {
-                    throw new ConnectionIdentityValidationError(
-                        translateDatabase('Database.Errors.ConnectionIdentityUpdateRequiresId'),
-                    );
+                    throw new ConnectionIdentityValidationError(translateDatabase('Database.Errors.ConnectionIdentityUpdateRequiresId'));
                 }
 
                 const { password, ...restIdentity } = identity;
-                const secret =
-                    typeof password === 'undefined' ? undefined : { passwordEncrypted: await encrypt(password ?? '') };
+                const secret = typeof password === 'undefined' ? undefined : { passwordEncrypted: await encrypt(password ?? '') };
 
                 await this.updateIdentityWithSecret(this.db, organizationId, connectionId, {
                     ...restIdentity,
@@ -307,7 +306,6 @@ export class PostgresConnectionsRepository {
         return updatedConnection;
     }
 
-
     async delete(organizationId: string, connectionId: string): Promise<any> {
         const deleted = await this.db
             .delete(connections)
@@ -368,21 +366,20 @@ export class PostgresConnectionsRepository {
             .where(and(...conditions));
     }
 
-
     async toConnectionListItem(db: DbExecutor, organizationId: string, row: any): Promise<ConnectionListItem> {
         // 1) SSH config
         const [sshRow] = await db.select().from(connectionSsh).where(eq(connectionSsh.connectionId, row.id)).limit(1);
         const sshConfig: ConnectionSsh | null = sshRow
             ? {
-                connectionId: sshRow.connectionId,
-                enabled: sshRow.enabled,
-                host: sshRow.host,
-                port: sshRow.port,
-                username: sshRow.username,
-                authMethod: sshRow.authMethod,
-                createdAt: sshRow.createdAt,
-                updatedAt: sshRow.updatedAt,
-            }
+                  connectionId: sshRow.connectionId,
+                  enabled: sshRow.enabled,
+                  host: sshRow.host,
+                  port: sshRow.port,
+                  username: sshRow.username,
+                  authMethod: sshRow.authMethod,
+                  createdAt: sshRow.createdAt,
+                  updatedAt: sshRow.updatedAt,
+              }
             : null;
 
         // 2) Identities list
@@ -440,8 +437,6 @@ export class PostgresConnectionsRepository {
         };
     }
 
-
-
     /* -------------------- Private helpers: SSH / Identity creation -------------------- */
 
     /**
@@ -482,7 +477,6 @@ export class PostgresConnectionsRepository {
         });
     }
 
-
     /**
      * Create identity + secret (for create)
      * Incoming secret fields are already *Encrypted
@@ -496,7 +490,6 @@ export class PostgresConnectionsRepository {
             secret?: Omit<ConnectionIdentitySecretUpsertInput, 'identityId'>;
         },
     ) {
-        console.log('Creating identity with payload:', payload);
         if (!payload.name || !payload.username) {
             throw new ConnectionIdentityValidationError();
         }
@@ -535,14 +528,14 @@ export class PostgresConnectionsRepository {
     }
 
     /**
- * Update identity + secret
- * - payload.id is required
- * - other fields optional; only update provided fields
- * - secret rules:
- *   - secret === undefined: no change
- *   - secret === null: delete existing secret
- *   - secret object: insert/update
- */
+     * Update identity + secret
+     * - payload.id is required
+     * - other fields optional; only update provided fields
+     * - secret rules:
+     *   - secret === undefined: no change
+     *   - secret === null: delete existing secret
+     *   - secret object: insert/update
+     */
     private async updateIdentityWithSecret(
         db: DbExecutor,
         organizationId: string,
@@ -552,8 +545,6 @@ export class PostgresConnectionsRepository {
             secret?: Omit<ConnectionIdentitySecretUpsertInput, 'identityId'> | null;
         },
     ) {
-        console.log('Updating identity with payload:', payload);
-
         if (!payload.id) {
             throw new ConnectionIdentityValidationError(translateDatabase('Database.Errors.ConnectionIdentityMissingId'));
         }
@@ -607,11 +598,7 @@ export class PostgresConnectionsRepository {
         }
 
         // Check existing secret
-        const [existing] = await db
-            .select()
-            .from(connectionIdentitySecrets)
-            .where(eq(connectionIdentitySecrets.identityId, identity.id));
-
+        const [existing] = await db.select().from(connectionIdentitySecrets).where(eq(connectionIdentitySecrets.identityId, identity.id));
 
         if (payload.secret === null) {
             return null;
@@ -624,14 +611,9 @@ export class PostgresConnectionsRepository {
             secretRef: payload.secret.secretRef ?? null,
         } as any;
 
-        return await db
-            .update(connectionIdentitySecrets)
-            .set(secret)
-            .where(eq(connectionIdentitySecrets.identityId, identity.id));
-
+        return await db.update(connectionIdentitySecrets).set(secret).where(eq(connectionIdentitySecrets.identityId, identity.id));
     }
 
-
     /**
      * Decrypt plaintext password by identityId (for testConnection)
      */
diff --git a/apps/web/lib/database/postgres/schemas/connections.ts b/apps/web/lib/database/postgres/schemas/connections.ts
index 735cbc02..5ddf76fe 100644
--- a/apps/web/lib/database/postgres/schemas/connections.ts
+++ b/apps/web/lib/database/postgres/schemas/connections.ts
@@ -2,7 +2,7 @@ import { boolean, integer, text, timestamp, pgTable, check, index, uniqueIndex }
 import { sql } from 'drizzle-orm';
 import { newEntityId } from '@/lib/id';
 
-export type ConnectionType = 'clickhouse' | 'doris' | 'mariadb' | 'mysql' | 'postgres' | 'sqlite';
+export type ConnectionType = 'clickhouse' | 'doris' | 'mariadb' | 'mysql' | 'neon' | 'postgres' | 'sqlite';
 export type ConnectionStatus = 'draft' | 'ready' | 'error' | 'disabled';
 export type SyncSource = 'local' | 'cloud';
 export type SyncStatus =
diff --git a/apps/web/lib/database/utils.ts b/apps/web/lib/database/utils.ts
index 62fb8eca..1185b9e5 100644
--- a/apps/web/lib/database/utils.ts
+++ b/apps/web/lib/database/utils.ts
@@ -5,6 +5,10 @@ export const DatasourceTypesWithDBEngine = [
         type: 'postgres',
         engine: 'postgres',
     },
+    {
+        type: 'neon',
+        engine: 'postgres',
+    },
     {
         type: 'clickhouse',
         engine: 'clickhouse',
diff --git a/apps/web/lib/explorer/capabilities.ts b/apps/web/lib/explorer/capabilities.ts
index 9c5d6ee2..0e7d289e 100644
--- a/apps/web/lib/explorer/capabilities.ts
+++ b/apps/web/lib/explorer/capabilities.ts
@@ -1,4 +1,5 @@
 import type { ExplorerDriver, ExplorerListKind, ExplorerObjectKind } from './types';
+import { isPostgresFamilyConnectionType } from '@/lib/connection/postgres-family';
 
 export type DriverCapabilities = {
     driver: ExplorerDriver;
@@ -89,6 +90,10 @@ export function resolveExplorerDriver(driver?: string | null): ExplorerDriver {
         return 'unknown';
     }
 
+    if (isPostgresFamilyConnectionType(driver)) {
+        return 'postgres';
+    }
+
     const normalized = driver.toLowerCase() as ExplorerDriver;
     return EXPLORER_CAPABILITIES[normalized] ? normalized : 'unknown';
 }
diff --git a/apps/web/lib/sql/sql-dialect.ts b/apps/web/lib/sql/sql-dialect.ts
index 4045c16c..6ca33940 100644
--- a/apps/web/lib/sql/sql-dialect.ts
+++ b/apps/web/lib/sql/sql-dialect.ts
@@ -1,6 +1,7 @@
 import type { ConnectionDialect } from '@/types';
 import type { ConnectionType } from '@/types/connections';
 import type { SqlLanguage } from 'sql-formatter';
+import { isPostgresFamilyConnectionType } from '@/lib/connection/postgres-family';
 
 export type SqlDialectParser = {
     getSuggestionAtCaretPosition?: (sql: string, caretPos: { lineNumber: number; column: number }) => unknown;
@@ -59,6 +60,7 @@ const SQL_DIALECT_BY_CONNECTION_TYPE: Partial<Record<ConnectionType, ConnectionD
     clickhouse: 'clickhouse',
     mariadb: 'mysql',
     mysql: 'mysql',
+    neon: 'postgres',
     postgres: 'postgres',
     sqlite: 'sqlite',
 };
@@ -85,6 +87,7 @@ export const normalizeSqlDialect = (value?: string | null): ConnectionDialect =>
         case 'mariadb':
             return 'mysql';
         case 'postgres':
+        case 'neon':
         case 'postgresql':
             return 'postgres';
         case 'sqlite':
@@ -99,7 +102,7 @@ export const getSqlDialectConfig = (dialect?: ConnectionDialect): SqlDialectConf
 };
 
 export const getSqlDialectConfigForConnectionType = (connectionType?: ConnectionType): SqlDialectConfig => {
-    const dialect = connectionType ? SQL_DIALECT_BY_CONNECTION_TYPE[connectionType] : undefined;
+    const dialect = connectionType ? (isPostgresFamilyConnectionType(connectionType) ? 'postgres' : SQL_DIALECT_BY_CONNECTION_TYPE[connectionType]) : undefined;
     return getSqlDialectConfig(dialect ?? 'unknown');
 };
 
diff --git a/apps/web/types/connections.ts b/apps/web/types/connections.ts
index c732c1d0..a2b55a8c 100644
--- a/apps/web/types/connections.ts
+++ b/apps/web/types/connections.ts
@@ -1,4 +1,4 @@
-export type ConnectionType = 'clickhouse' | 'doris' | 'mariadb' | 'mysql' | 'postgres' | 'sqlite';
+export type ConnectionType = 'clickhouse' | 'doris' | 'mariadb' | 'mysql' | 'neon' | 'postgres' | 'sqlite';
 export type ConnectionStatus = 'Connected' | 'Error' | 'Disconnected';
 export type ConnectionCheckStatus = 'unknown' | 'ok' | 'error';
 export type ConnectionIdentityStatus = 'active' | 'disabled';