# Post-Install Checklist

> Source: https://docs.synthesized.io/tdk/latest/user_guide/050_deployment_operations/deployment/post_install_checklist
> For the complete documentation index, see [llms.txt](https://docs.synthesized.io/llms.txt).

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**:

```shell
# 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**:

```shell
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](http://localhost:8080/actuator/health)`
- Web UI accessible in browser
- Can log in with credentials
- API responds: `curl [http://localhost:8080/api/version](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**:

```shell
docker compose logs backend
docker compose logs worker
docker compose logs postgres
```

**Kubernetes**:

```shell
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**:

```shell
# 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**:

```shell
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**:

1. Create workflow in UI or via YAML
2. Configure simple Email masking
3. Select small table (< 1000 rows)
4. Run workflow
5. Monitor execution
6. Verify completion

**Expected duration**: < 1 minute for small table

### Step 5: Verify Output

**Check output database**:

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

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

**Verify referential integrity**:

```sql
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](https://docs.synthesized.io/tdk/latest/user_guide/080_troubleshooting/common_issues/installation)

### Can’t Access Web UI

**Check**:

- Backend is running
- Port 8080 is accessible
- No firewall blocking
- Browser can reach server

**Test**:

```shell
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](https://docs.synthesized.io/tdk/latest/user_guide/080_troubleshooting/common_issues/connection)

## Performance Baseline

Run baseline performance test:

```yaml
# 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:

1. **Change all default passwords**
2. **Disable demo users** (if any)
3. **Configure authentication**:
  
  - [SSO](https://docs.synthesized.io/tdk/latest/user_guide/060_security_compliance/authentication/sso)
  - [LDAP](https://docs.synthesized.io/tdk/latest/user_guide/060_security_compliance/authentication/ldap_activedirectory)
4. **Set up RBAC**: [Role-Based Access Control](https://docs.synthesized.io/tdk/latest/user_guide/060_security_compliance/rbac/)
5. **Enable HTTPS**
6. **Configure secret managers**: [Secret Management](https://docs.synthesized.io/tdk/latest/user_guide/070_integrations/secret_management/)
7. **Review logs** regularly
8. **Set up monitoring**: [Monitoring](https://docs.synthesized.io/tdk/latest/user_guide/050_deployment_operations/monitoring/)

## Next Steps

After completing this checklist:

1. **Import production workflows** (or create new ones)
2. **Set up data sources** for actual databases
3. **Configure user accounts** and permissions
4. **Set up scheduled workflows** (if needed)
5. **Configure monitoring** and alerting
6. **Test disaster recovery** procedures
7. **Document your deployment** specifics

## Get Help

If you encounter issues:

- [Troubleshooting Guide](https://docs.synthesized.io/tdk/latest/user_guide/080_troubleshooting/)
- [Run Diagnostics](https://docs.synthesized.io/tdk/latest/user_guide/080_troubleshooting/common_issues/diagnostic)
- [FAQ](https://docs.synthesized.io/tdk/latest/faq/synthesized-platform)