Begin by examining the schema of your PostgreSQL database. Identify the tables, data types, constraints, and relationships between tables. This understanding will be crucial in mapping the data to a DynamoDB-compatible format since DynamoDB is a NoSQL database and has different requirements for data structure.

Log in to your AWS Management Console and navigate to the DynamoDB service. Create a new DynamoDB table that corresponds to the data you plan to migrate. Define the primary key and any secondary indexes you might need. Keep in mind DynamoDB's limitations such as item size and attribute types when planning your table structure.

Execute a SQL query for each table you want to export and save the results in a CSV or JSON format. Use the PostgreSQL `COPY` command to write the table data to a file on your disk:
```sql
COPY your_table_name TO '/path/to/your_file.csv' DELIMITER ',' CSV HEADER;
```
Ensure that the data types are compatible and that you handle NULL values appropriately.

Write a script to transform the exported data into a format that DynamoDB can accept (JSON is recommended). This transformation may involve converting data types and restructuring data to fit DynamoDB's flat schema requirements. Python's `boto3` library can be useful for this task:
```python
import csv
import json

def transform_csv_to_json(csv_file_path, json_file_path):
with open(csv_file_path, mode='r') as csv_file:
csv_reader = csv.DictReader(csv_file)
data = [row for row in csv_reader]

with open(json_file_path, mode='w') as json_file:
json.dump(data, json_file, indent=4)
```

Use the AWS SDK (e.g., `boto3` for Python) to write the transformed data to your DynamoDB table in batches, as DynamoDB has a limit on the number of write operations per second. Here's a basic example using `boto3`:
```python
import boto3

def batch_write_to_dynamodb(json_file_path, table_name):
dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table(table_name)

with open(json_file_path) as json_file:
data = json.load(json_file)
with table.batch_writer() as batch:
for item in data:
batch.put_item(Item=item)

batch_write_to_dynamodb('/path/to/transformed_data.json', 'your_dynamo_table_name')
```

After the data transfer, verify the integrity of the data in DynamoDB. You can do this by running queries to ensure that key data points match between PostgreSQL and DynamoDB. Check the count of items and spot-check individual records for accuracy.

Once the data migration is complete, monitor the performance of your DynamoDB queries and optimize as necessary. This may involve adjusting the read/write capacity units, creating additional indexes, or restructuring data access patterns to fit DynamoDB's strengths. Utilize AWS CloudWatch to keep an eye on the performance metrics of your DynamoDB tables.

By following these steps, you can effectively transfer data from PostgreSQL to DynamoDB without relying on third-party tools.