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

Workers (if using worker mode)

Worker containers/pods are running
Workers registered with backend
Check backend UI: Settings → Workers
Workers show "Connected" status
Test worker execution with simple workflow

Networking

Frontend can reach backend (check browser console)
Backend can reach metadata database
Workers can reach backend (if using workers)
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 worker
docker compose logs postgres

Kubernetes:

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

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

Worker Won’t Connect

Check:

Worker container is running
BACKEND_URL environment variable correct
Network allows worker → 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: