Post-Install Checklist

Verify your platform deployment is working correctly with this comprehensive post-installation checklist.

Quick Verification

After installing the platform, verify these essentials:

1. Service Health

Check all containers are running:

# Docker Compose
docker compose ps

# Kubernetes
kubectl get pods -n tdk

Expected output: All services in "Running" or "healthy" state

2. Web UI Access

Open browser:

http://localhost:8080

or your configured domain

Expected: Login page displayed

Test login with credentials: * Default demo: test@synthesized.io / Qq12345_ * Or your configured admin user

3. Database Connectivity

Run diagnostic:

tdk diagnostic --check-connection

Expected: Successful connection to metadata database

Comprehensive Checklist

Backend Server

Backend container/pod is running
Backend logs show no errors
Health endpoint responds: curl http://localhost:8080/actuator/health
Web UI accessible in browser
Can log in with credentials
API responds: curl http://localhost:8080/api/version

Metadata Database

PostgreSQL container/pod is running
Database accepts connections
Tables created (check with psql/pgAdmin)
Backend can connect to database
Migrations completed successfully

Agents (if using agent mode)

Agent containers/pods are running
Agents registered with backend
Check backend UI: Settings → Agents
Agents show "Connected" status
Test agent execution with simple workflow

Networking

Frontend can reach backend (check browser console)
Backend can reach metadata database
Agents can reach backend (if using agents)
The platform can reach source/destination databases
Firewall rules allow required ports

Security

Change default passwords
Configure authentication (LDAP/SSO if needed)
Set up RBAC roles
Configure secret managers (if using)
Enable HTTPS/TLS
Review and set application properties

Test Workflow

Create test workflow (simple masking)
Run workflow successfully
Check execution logs
Verify output database has data
Validate referential integrity

Detailed Verification Steps

Step 1: Check Logs

Docker Compose:

docker compose logs backend
docker compose logs agent
docker compose logs postgres

Kubernetes:

kubectl logs -n tdk deployment/tdk-backend
kubectl logs -n tdk deployment/tdk-agent

Look for: * No ERROR or FATAL messages * Successful database connections * "Application started" messages

Step 2: Test Database Access

Connect to metadata DB:

# Docker Compose
docker exec -it <postgres-container> psql -U postgres -d tdk

# Check tables exist
\dt

Expected tables: * workflow * workflow_execution * users * projects * (and others)

Step 3: Create Test Data Source

Via UI: 1. Navigate to Data Sources 2. Click "Add Data Source" 3. Enter test database connection 4. Click "Test Connection" 5. Save if successful

Via API:

curl -X POST http://localhost:8080/api/datasources \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{
    "name": "Test Database",
    "url": "jdbc:postgresql://host:5432/testdb",
    "username": "user",
    "password": "pass"
  }'

Step 4: Run Test Workflow

Simple masking workflow:

Create workflow in UI or via YAML
Configure simple Email masking
Select small table (< 1000 rows)
Run workflow
Monitor execution
Verify completion

Expected duration: < 1 minute for small table

Step 5: Verify Output

Check output database:

SELECT COUNT(*) FROM masked_table;
-- Should match source row count

SELECT email FROM masked_table LIMIT 5;
-- Should show masked emails

Verify referential integrity:

SELECT COUNT(*)
FROM child_table c
LEFT JOIN parent_table p ON c.parent_id = p.id
WHERE p.id IS NULL;
-- Should return 0 (no orphaned records)

Common Issues

Backend Won’t Start

Check: * Metadata database is running and accessible * Database credentials are correct * Required environment variables set * Sufficient memory allocated

See: Installation Issues

Can’t Access Web UI

Check: * Backend is running * Port 8080 is accessible * No firewall blocking * Browser can reach server

Test:

curl -I http://localhost:8080

Agent Won’t Connect

Check: * Agent container is running * BACKEND_URL environment variable correct * Network allows agent → backend communication * Backend is ready (not still starting)

Database Connection Fails

Check: * Database is running and accessible * Credentials are correct * JDBC URL format is correct * Network/firewall allows connection

See: Connection Issues

Performance Baseline

Run baseline performance test:

# Test workflow: Generate 10,000 rows
table_schema:
  - table_name_pattern: "test.customer"
    num_rows: 10000
    transformations:
      - columns: ["id"]
        type: Sequence
      - columns: ["email"]
        type: Email

Expected performance: * Good: > 5,000 rows/second * Acceptable: 1,000-5,000 rows/second * Slow: < 1,000 rows/second (investigate)

Security Hardening

After verification, harden security:

Change all default passwords
Disable demo users (if any)
Configure authentication:
- SSO
- LDAP
Set up RBAC: Role-Based Access Control
Enable HTTPS
Configure secret managers: Secret Management
Review logs regularly
Set up monitoring: Monitoring

Next Steps

After completing this checklist:

Import production workflows (or create new ones)
Set up data sources for actual databases
Configure user accounts and permissions
Set up scheduled workflows (if needed)
Configure monitoring and alerting
Test disaster recovery procedures
Document your deployment specifics

Get Help

If you encounter issues: