Use React Native to post to secure AWS API Gateway endpoint

I am setting up a React Native application that will interface with an authenticated API hosted by AWS API Gateway. Here is how I set up my API to be secured through authentication. I am not sure that this will be used in production, but it is working well for testing.

This post will go over the following:

  1. Setting up a very simple React Native application
  2. Adding a simple button that will later be used to get data from an endpoint
  3. Using the react-native-dotenv module for environment set up
  4. Using the react-native-aws-signature module for authorization
  5. Debugging with react-native-aws-signature

Here is the code for this example on githhub

Setting up a very simple React Native application

Start with a brand new react-native application. To set one up, run:

You should get something in the simulator that looks like this:

Adding a simple button that will later be used to get data from an endpoint

In the index.ios.js file, add Button to the imports:

Replace the existing SampleProject Component with this:

Reloading in the simulator should give you something like this:

If you press the ‘API Request’ link, you should get this:

Using the react-native-dotenv module for environment set up

In a production mobile application, you don’t want to save secret API keys anywhere in the code because it can be reverse engineered. There is a SO post here about it.

That being said, if you are only installing the app on your phone during the testing phase, it is probably fine.

The official react-native-dotenv instructions are here, but this is what I did to set it up.

First, install the module

Add the react-native-dotenv preset to your .babelrc file at the project root.

Create a .env file in your project root directory with your AWS credentials and the host.

Now, let’s set up a really simple class that we will use to interface with our API. This should be at the same level as index.ios.js, and mine is called called SampleApi.js.

Then, somewhere near the top of index.ios.js, import the new class:

Replace the retrieveData function with:

Our full index.ios.js should now look like:

Note: if you change the .env file only, the simulator will not recognize the change and your changes will not take affect.

Using the react-native-aws-signature module for authorization

Now, we want to actually hit the API when the button is pressed. Start by installing the react-native-aws-signature module

In SampleApi.js, add the import for AWSSignature:

Remove the contents of the get() method in SampleApi.js and start by setting up some variables based on the .env file:

Next, set up the header and options. These will be used to generate the authorization details and they will be used in the request to the API.

Then, create a new AWSSignature object and call setParams. This will generate the authorization header, which we retrieve in the next bit of code:

Now, retrieve the authorization information and append it to our header.

Finally, make the request to the API using the header we just created. We are expecting json back, and I have included some basic error checking.

Here is what the SampleApi.js file should now look like:

Modify index.ios.js to set the state to include the return value of the request. Since we are getting a json array back, we have to loop through it to make a readable text block:

After you refresh the simulator, you should be able to press the button and receive a screen that looks something like this:

Debugging with react-native-aws-signature

This AWS troubleshooting guide is helpful, but react-native-aws-signature does most of the work for you, so it can be difficult to determine where your mistakes are.

I got this error when I was including the https:// at the beginning of the host parameter in the header. The full error includes what AWS was expecting for the ‘canonical string’ and the ‘string to sign’.

I figured out how to fix the issue by using the getCanonicalString() and getStringToSign() methods.

 

Create secure endpoints for AWS API Gateway

I am building an application that will rely on the AWS API Gateway for a REST API. I want to make sure that other people are not able to read or write data on the endpoints. I will be using IAM authentication, using the steps below:

  1. Set up an example API
  2. Test that the API works without authorization
  3. Enable authorization on your endpoints
  4. Set up a new User in IAM for API requests
  5. Configure your request to use your credentials

Set up an example API

If you already have an API set up, skip this part.

From API Gateway, select “Create API”.


On the next screen select “Example API” and click “Import”.

The UI will then prompt you to “Deploy API”, if it doesn’t, you can select the option from the “Actions” dropdown. You must provide a stage name for the deploy, I just used ‘test’.

After you have deployed the API, you should see a screen like this, that includes a link to the API.

Click on the link and it will bring you to an info page. We will test the endpoint in the next step.

Test that the API works without auth

Now, make sure you can get to your endpoints without authentication. You can test the GET endpoint by appending ‘/pets’ to your url, either in a browser or with an application like Postman.

The browser output will look something like this:

The Postman output will look something like this:

Enable authorization on your endpoints

Now, let’s lock down the API so only we can get to it. In API gateway, select the /pets GET resource:

Then go to the configs for the Method Request and select ‘AWS_IAM’ under the Authorization setting.

In order for the changes to take affect, you have to use the “Deploy API” action under the “Actions” dropdown. You can deploy over an existing stage, or create a new one.

Now when you try to hit the endpoint via the url, you should get this response

Set up new User in IAM for API requests

Go to your IAM setup and add a new group with the following permissions: AmazonAPIGatewayInvokeFullAccess

Set up a new user that is a part of the group you just created. You won’t need to log in as that user, so don’t set up a password.

On the last screen, the credentials will be provided, make sure you capture both the Access Key ID and the Secret access key, the secret key won’t be displayed again.

Configure your request to use your credentials

In order to get to our endpoint, we need to include authorization values in the header. These are calculated at the time of the request to make sure other people cannot just reuse your headers to gain access.

Here are the full instructions from Amazon, but Postman makes it pretty easy.

Under the “Authorization” tab, select “AWS Signature”

You will be taken to this screen where you can enter the configuration:

The configuration includes:

  • AccessKey – This is the Access Key ID that we copied in the previous step, it is the shorter of the keys
  • SecretKey – This is the “Secret Access Key” that was copied in the previous step, it is the longer of the keys. (It should never be shared)
  • AWS Region – This is ‘us-west-2’ for me, but may be different for you
  • Service Name – this should be ‘execute-api’

After you have entered the values, press “Update Request”. Now if you try to access the endpoint, you should get the data as before.

Check out the values that were included in the “Headers” tab. The ‘X-Amz-Date’ and ‘Authorization’ will change with each request and they are what Amazon verifies on their end to ensure you have up to date permissions.

Next Steps

In order to use the API from an application, you will need to systematically add the headers to your requests. I am using react-native-aws-signature for my React Native application.

Using Amazon Web Services to create a serverless web app

Amazon Web Services (AWS) provides resources that can take the place of a traditional webserver. A huge advantage to this approach is removing the need for the developer to maintain servers, and to allow for easy scaling depending upon use.

In my project, I want to set up mobile app that will use AWS as a backend. I plan on using the following services:

  • Lambda – allows you to run arbitrary code without setting up a server
  • Relational Database Service (RDS) – hosted database. I will be using postgresql
  • Step Functions – Connect services together using visual workflows
  • API Gateway – Create API endpoints to allow your backend to be used outside of AWS

Other technology I will be using

  • Node.js – I am new to JavaScript and want to learn more about it
  • PostgreSQL
  • Bookshelf.js/Knex – I want a well supported ORM that supports PostgreSQL. Bookshelf.js seems robust and since it is built on top of Knex, I can always fall back to Knex for unsupported functionality.
  • node-lambda – Make it easier to manage AWS Lambda deployment

Here is an outline of my steps

  • Set up PostgreSQL and Bookshelf.js
  • Set up hosted database using RDS
  • Create simple lambda that reads from RDS
  • Integrate API Gateway with Lambda
  • Connect 2 Lambdas together with Step Functions
  • Integrate API Gateway with Step Functions

Set up Bookshelf.js for Node.js

Intro

I am going to walk through setting up a brand new Node.js project using Bookshelf and PostgreSQL. At the end, we will have a simple Node.js project that can insert and retrieve data from a database.

Here is what this post will cover

  • Set up a new Node.js project
  • Install necessary libraries to interface with PostgreSQL database
  • Set up process to create a database table
  • Use Bookshelf to
    • insert data
    • retrieve data

The code for this post can be found here.

Why Bookshelf.js?

Bookshelf.js is an Object Relational Mapping (ORM) for Node.js that allows developers to more easily interface with a relational database. It allows the dev to focus on higher level functions, rather than low level queries. It takes care of some basic attribute mapping to make data models simpler. It also allows for the same code to be used against different relational databases in case you want to change the underlying database.

I chose Bookshelf.js because it is well maintained, well documented, and it is built on Knex.js, which is a SQL query building framework. I can use Knex for queries that are not easily supported in Bookshelf.

Install necessary software

Node.js

I am using Node.js 4.3.2 because 4.3 is what is supported in AWS Lambda. If you don’t have node installed, follow these instructions.

PostgreSQL

Instructions on how to install PostgreSQL. I use Postico to easily interface with the PostgreSQL.

Before we go on, start the database.

Set up a new Node.js project

Set up the project directory and initialize the project. When you run npm init, it will prompt you to answer some questions, you can use the default values or set your own, at this point they don’t matter too much.

Install the node modules that we will need, the -save option will add the modules to the package.json file.

Here is what each module does

  • bookshelf – the ORM we will be using
  • knex – required by bookshelf, but in the future it may not be included automatically
  • pg – the postgresql module
  • dotenv – a utility that makes dealing with environment variables easy

Here is our current package.json

The dotenv module reads from a .env file in the project directory. This will set the environment variables. Right now we only need to set which environment we are in.

Hello (node) world

Let’s create a simple javascript file named index.js that will show that we have node working.

Now, make sure that it works

Create a database

Let’s create our database, and verify that it exists.

Create table in database

Set up a knexfile.js config file for Knex. This tells Knex how to connect to the database, notice there are entries for development and production. Right now we care most about development.

Now create a migration that will define our table. The resulting XXXXX_create_table.js file is just a blank template that we will fill out. Yours will have a different date and time in the name.

Later, we will be using the test jsonAPI here. To keep it simple, let’s just create a table that replicates the post resource, which has data like this:

Edit the XXXXX_create_table.js file to include the columns we want our table to have. Mine looks like this

This will create a table called ‘articles’.  We have an id field that will automatically increment when we insert new records. The remote_id is the id from the test service, we want to be sure that we don’t have duplicates, so we use the .unique() method. The table.timestamps(); command will add a created_at and updated_at column that are automatically populated when a record is added or updated. I have excluded the user_id that appears in the test API to keep the table simple.

The exports.down function defines what should happen if we rollback the migration, in general this should do the reverse of what the exports.up function does.

Now, run the migration with knex migrate:latest, and make sure the table exists.

Set up Bookshelf

Start with a bookshelf.js file that will allow us to use bookshelf in other files.

Create a model class for the articles table that we can use to interface with the table. By extending the bookshelf.Model, we get functionality that allows us to access the attributes of the table as methods on the Article variable.

Insert data into the table

Edit index.js to create a new entry in the articles table

Run index.js and make sure that it adds data to the table.

Retrieve data from the database

Now, modify index.js to also query the database for the article we just inserted. Below we have added the getInsertedArticle function, commented out the code that just did the insert, and added some new code to insert and then retrieve the record.

Done

That is it. There are many more things we can do with a database, like create relationships, do complex joins, etc., but this is a good starting point.

Here is a link to the code from this post.

Working with servos and an Arduino Nano clone

Over the past few weeks I have been working on building the software to allow my RC Sailboat to sail autonomously. To keep the form factor as small and light as possible, I bought a cheap Arduino Nano clone to use in place of an Arduino Uno.

Nano with rudder and Sail
Nano microcontroller with servos for sail and rudder control

Obstacle 1: drivers

My first obstacle was getting my mac to communicate with the board. The basic issue is that the WCH340G USB interface chip on the clone is different than the FTDI FT232RL used on the authentic Arduino Nano. There are many sites with instructions and links to drivers, but this one had the most up to date driver that was signed. The older drivers were not signed and required me to bypass OSX’s security to allow unsigned drivers. direct link to driver download

Obstacle 2: consistent power

I had some semi-working software running on the Uno that would adjust a sail and rudder servo. When I swapped in the Nano the servos generally worked, but would sometimes move wildly. Since the Nano and Uno are very similar (chip, ram, clock speed, etc.) I figured the issue was going to be with the power or maybe the WCH340G USB chip.

To troubleshoot I used my voltmeter to see how the Nano voltage changed while adjusting the servos. When not moving the servos, it put out 4.8V on the 5V pin and while moving the servos simultaneously it would drop to ~4.2V. The servos expect 4.8-6V so this could contribute to the issue. As reference, the Uno put out 5V, I didn’t test it while moving servos.

In the past I have had issues with macs not putting out enough voltage through USB, and I have a cord that includes 2 plugs, one for power and one for power+data. The cord is similar to this one.

I swapped out the cords and the servos started behaving as expected. My guess is that a combination of data transfers (to signal the servo change) and keeping a consistent power supply were too much for the single cord.

Since I want to run the system without my computer, I think the USB cord is not the best solution. A couple of alternative options are a separate power supply for the servos, or using a capacitor to smooth out the power.

To keep down weight and complexity, I took the capacitor approach. I found many sources that said a minimum of 470uF was the correct capacity and that the voltage rating should be 3x what you have in the system. I added a single 1000uF/25V capacitor with the old cord and the servos behaved well. The servos also worked well with three 100uF/16V capacitors in parallel, but I prefer the single capacitor solution.

Building nightstands

Introduction

I designed matching nightstands, this page shows how I built them.

Pair of finished nightstands
Pair of finished nightstands

Finished nightstand

Lumber

I wanted dark wood that was inexpensive and easy to work with. I went to Crosscut Hardwoods in Seattle and it was amazing. The staff was super helpful and directed me to roasted poplar. Poplar is normally a blonde color, but they put it into a kiln and it turns a dark brown throughout. Nearly all of the water was removed in the roasting process and then the lumber was cut, so there is very little warping. Also, it has a nice campfire smell.

The lumber was 8-10 inches wide and a full inch thick, which is thicker than I was looking for, but something remedied with a planer.

I bought jatoba (Brazilian Cherry) for the sides of the drawers, mainly because it was already a 1/2 inch thick and I liked the color contrast with the roasted poplar.

I bought 1/8 in. mahagony veneer plywood for the bottoms of the drawers.

Roasted poplar
Roasted poplar

Construction

I spent a full weekend with my dad in his shop creating the nightstands.

Edge Joining

We had to edge join many pieces, but we wanted to get them to the basic length and thickness first. We used a 12 in. planer to bring the thickness from 1 in. to 3/4 in. This was a lot of work.

We drilled holes in the edges to receive dowels, then glued the pieces together and let sit over night.

Doweling jig ready for drilling.
Doweling jig ready for drilling.
Edge joined pieces right after gluing
Edge joined pieces right after gluing
Edge joined piece with the glue wiped off.
Edge joined piece with the glue wiped off.

After the glue was set, we cut the pieces to the exact dimensions. We used a thickness sander to smooth out imperfections of the joint, remove glue residue and get the pieces to the desired thickness.

Drawers

Although I had designed the drawers on paper, I wanted to be sure we had a design that would work with the runner, so I created a wood prototype.

Figuring out how the runners and drawers will work together.
Figuring out how the runners and drawers would work together.

Once I had a good idea of how the runners would work, we attached them to the sides of the stands. There was a lot of trial and error to get them even.

We used self drilling screws to assemble the drawers, predrilling the jatoba because it is such a hard wood.

Finished drawer
Finished drawer
Back of faceplate
Back of faceplate
Back of drawer, recessed to allow for cords to go behind the drawers.
Back of drawer, recessed to allow for cords to go behind the drawers.

Dados

We cut dados for the shelves and the backs of the nightstands.

Dado through a dowel, lucky I guess.
Dado through a dowel, lucky I guess.

Side with dados

Finishing

Prepping for sanding

There were several gaps and imperfections that needed to be filled in, most were small enough that a mixture of sawdust and glue worked well. There were a few gaps that I filled first with slivers of wood and then finished with the sawdust and glue mixture. When mixing, I went for as little glue as possible, while still getting a tacky feel.

I used too much putty in a few places that required a lot more sanding.

Putty made from mixture of sawdust and wood glue.
Putty made from mixture of sawdust and wood glue.
A larger gap that needed to be filled with both slivers of wood and putty.
A larger gap that needed to be filled with both slivers of wood and putty.
Same gap, filled with slivers and putty.

Smoothing and Sanding

I used a card scraper to get the surfaces flush with each other, this worked great and was much faster than sanding. I then used an orbital sander with 150 grit sandpaper. I didn’t spend a lot of time sanding the inside faces.

Polycrylic

I used Minwax Polycrylic waterbased clear matte finish. This was really low odor and dried fast. I did 3 coats, sanding with 220 by hand between coats. Since the drawer faces and top were going to be the most visible, I did an extra couple of coats and sanded with 320 between the final coats.

Before finish on right, after finish on left
First coat of polycrylic
First coat of polycrylic

Finished nightstand

Pair of finished nightstands
Pair of finished nightstands

Finished nightstand

Finished nightstand

Designing nightstands

We were looking for nightstands that wouldn’t take up too much room and would still be functional. We found that many of the options were either ugly, too big, too expensive, or a combination of all three. I decided that I could design and build nightstands that would meet our needs and it would be a fun project.

Requirements

  • Dark wood
  • 12 inches wide
  • A drawer or two to reduce clutter
  • A shelf for cell phones

Planning

Inspiration

I found a few designs that were similar to what we were looking for, here is my pinterest board with some inspiration.

Sketching

I started with some simple sketches to figure out how the proportions would work and to see if two drawers were too many.

From the inspiration night stands and through my sketches, I realized that I would prefer to have drawers without pulls, to give a sleek look.

Designing

I spent some time in Illustrator laying out several options. Since neither of us have many large books and we have a separate bookshelf, we decided that a shorter bottom shelf was a good compromise for 2 drawers.

Possible designs for nightstand
Possible designs for nightstand, including pull cutouts. (I went with E)

(Almost) final plans

Nightstand Views

The pieces that are required for the nightstand
The pieces that are required for the nightstand

The grid squares are 1/2 inch. I assumed 3/4 in. thick boards, except for on the drawers. Most of the faces are wider than regular lumber, so I assumed we would have to edge join pieces to make boards that were wide enough.

The drawer front pieces, which are just behind the faceplate are a bit shorter to make sure your hand doesn’t hit them when you pull the drawer open.

The gap behind the drawer was originally created to allow a cord to go behind the drawers, but I instead opted for drilling a hole in the back of the nightstand.

The drawer bottoms are 1/8 in. plywood.

I used Ikea Besta drawer runner slides. The plans are missing the details on where the slides are positioned. This was something we figured out at build time.

Prototyping

To make sure the nightstand would be an appropriate size, I created a very rough prototype out of cardboard. I was happy with the size and dimensions and was ready to start the build process.

Cardboard prototype

The build process: Building nightstands

How to display Google Earth maps on website

When I hike, I track my routes with a GPS and import them into Google Earth. This works great on my personal computer, but it doesn’t allow me to easily embed the maps on a webpage. To allow others to view my maps, I import them into Google Maps and then embed these custom maps on my webpage.

Steps to embed Google Earth routes on webpage using Google Maps

  1. In Google Earth, right click on the route you want to save and select “save place as”save place as
  2. Save the file as a .kml
  3. Sign in to Google Maps and open the menu on the left side of the search bar by clicking the three line icon
    menu
  4. Within the menu, select “Your Places”, then the “Maps” tab.
    your places
    Maps tab
  5. This page will show all of your custom maps, click the “Create Map” link at the bottom of the page
  6. The map edit screen will open with one map layer created for you. Click “import” under the layer. This will let you select the .kml file that you created earlier.
    import
  7. If you want to add multiple routes to the same map (for instance a multi-day hike), add a new layer with the “Add layer” link, and import a separate .kml file.
  8. You can change the look of the map. These changes will be reflected on the embedded map if you change them in the future.
    • To change the color of the route, mouse over the name at the bottom of the layer section (“Enchantments Through hike” in the images below) and click the paint bucket icon.
      color
    • To add a label to the route, click on the “Individual styles” link and select the label you want to show.
      label
    • You can change the type of map (terrain, satellite, etc.) from the “Base Map” link under the layers section.
  9. In order to embed the map, you will have to make the map public through the “share” link.
    public
  10. Once the map is public, you can select the “Embed on my site” item from the menu.
    embed on my site
  11. Insert the provided code on your site, and you are done.
    copy code

 

Here is an example of an embedded map

Viking burial

A viking burial for a frog

Why I am building the boat: Balsa viking boat

How I made the plans: Viking boat plans

Boat construction: Viking boat construction

Preparation

We wanted the boat to sink when it was done burning, so we added some rocks in the compartments at the bow and stern.

We also wanted to be sure Freddie burned before the boat sank, so we added a bed of wood shavings and kindling around the internal deck. We also used long pieces of cedar to look like oars raised in the sky.

We attached a wire loop to each end of the boat and then tied fishing line to the loops. This way we could easily keep the boat centered in the pond.

Adding Freddie

Freddie had spent the last several decades in a jar of formaldehyde and had pretty much decomposed into a cloudy solution. There were still some solid parts, so we created a net of cheesecloth with a wire hanger and poured him into it. We rinsed him off with alcohol to make him more flammable, wrapped him in the cheesecloth to create a shroud, and placed him in the boat.

Too long in a jar
Too long in a jar

The sending off

My mom created a sound track for the funeral which included Turn! Turn! Turn! by The Byrds and Joy to the World by Three Dog Night.

We gathered around the pond, started the music and then lit the boat on fire. It burned quite well and by the second round of Joy to the World, the boat had burned down to the bottom of the hull, turned over, and sank bottom up to bottom of the pond.

Boat at the bottom of the pond

Viking boat construction

Intro

Here are the basic steps I took to build the boat. I am happy with how it turned out. It was fun to build something that I knew was going to be destroyed, it was liberating to not get too hung up on making it perfect.

My general approach was to fit the wood as best as I could and sand down the imperfections. This worked pretty well, especially because balsa and bass wood sand easily.

Why I am building the boat: Balsa viking boat

How I made the plans: Viking boat plans

How I destroyed the boat: Viking burial

Materials

Unfortunately, I didn’t document the pieces of balsa that this required, and since the boat burned up, I can’t really create an exact list now.

Rough list of materials:

  • Bulkheads: 10 total – 1/16in. thick balsa
  • Strakes: 8 total – 1/16in. x 1/16in. balsa
  • Gunnels: 2 total – 3/32in. x 3/32in. balsa
  • Keel: 2 pieces – 1/8in. wide 3/32in. thick balsa
  • Planking: I used a mix of 1/4in. and 1/2in. wide bass wood, both 1/32in. thick. Bass wood is a little stronger than balsa and it was easier for me to find thinner bass wood. From the pictures, it looks like I used about 16-20 1/2in. planks.
  • Bow and Stern towers: 6 total – 1in. wide 1/16 thick balsa.
  • I used BSI Insta-cure+ Glue, it cures very fast and is really strong. I have found this to be the best glue for bending balsa and getting it to stick.
  • paraffin wax for waterproofing – 1/2 pound
  • Bottlecaps for shields – 8 total

Creating the jig

I used a jig to help secure the boat during most of the construction.

The jig had 10 blocks, with 2 inches between the left sides of each block, except for the middle two, which were 4 inches apart. This way when the bulkhead tabs were glued to the jig, they were 2 inches apart.

In order to keep the boat true, it was important that the blocks were square to the base and that the middle of the bulkhead tabs were centered. I wish I had done a better job of sighting down the bulkheads as I glued them to make sure they were aligned.

Cutting out the bulkheads

I printed the plans out on paper, cut each piece out roughly, and then taped the paper onto the balsa. I used an exacto knife to trace the printout and cut the wood. My main focus was on getting the outline traced smoothly on the first pass and then going deeper with the subsequent passes.

Cutout bulkheads. The bulkheads have and extra tab on the bottom of 1, 2, 9, and 10. These are not necessary and no longer part of my plans.

The strakes

I then added the strakes. I started from the middle of the boat securing 2 bulkheads at a time. Balsa bends pretty easily, but I ended up breaking a few pieces on the ends. I have since updated the plans to make bulkheads 2 and 9 a little wider, which might help.

First couple of strakes

The planks

I added the planks starting from the middle of the hull and working my way up the sides. Again gluing two bulkheads at a time, starting from the middle. It had a hard time bending the bass wood enough to lay each plank along the one before it. I ended up overlapping many of the planks with a less extreme curve. I didn’t worry about planking along the super steep keel part to start.




As you can see, I didn’t align the ends, after the planks were in place, I used a dremel tool to shape the ends.

Rough ends
Ends shaped by the dremel tool

To fill in some gaps, I used smaller planking cut to length. I found the easiest way was to just eyeball the length, score the wood and then break it by hand. You can see this planking in the pictures below.

The keel

I used 1/4 in. wide balsa to build up the keel on the steep part of the bulkheads. Then I capped the keel with another 1/4 in. piece. Once this was in place I used an exacto knife to trim the excess and then sanded it to be flush with the planking. I then added thicker pieces on top to make the keel deeper.

I also added some thin pieces to the end of the bow and stern to smooth them out a bit.

At this point I cut the boat away from the jig with scissors.

Before trimming the excess
Before trimming the excess
Keel with extra depth and bow cap in place
Keel with extra depth and bow cap in place

The towers

While adding the planks, I didn’t worry about building up the towers on the bow and stern. I added some pieces after the fact that added probably 6 in. of height. I then used the dremel tool to shape them. I broke the bow dragon while shaping it, so I ended up creating a new one with thicker wood and just glued it to the bow.

Waterproofing

I wanted the boat to float, and use materials that were ok to burn in a pond with fish. I figured that paraffin wax was a good material for waterproofing.

I started by lining the boat with tissue paper and pouring wax over it. I thought that this would create a barrier and that I could then add wax on the outside. I then poured wax over the outside to fill in the bigger gaps.

The wax on the outside of the boat helped prevent the wood from soaking up water. I found the best method was to pour some wax on the boat and then work it into the cracks using a small piece of wood like a squeegee.

The tissue paper didn’t stick well to the hull, and it allowed small leaks, so I removed it and just pouring wax on the inside and moving it around to fill in the holes.

Throughout the waterproofing I floated the boat a couple of times to identify leaks. I used a lot more wax than I would if I wasn’t burning the boat, but I wasn’t too concerned about how the inside looked.

Finishing touches

I added some decking on the bow and stern to give a more finished look, and also built up the deck on the inside to hold Freddie. I added bottlecaps as shields along the side.