Boon Blog

Test Flake: Chrome Clicks

2026-06-05T00:00:00-07:00

This is the first in what I expect to be an ongoing series of posts on common sources of test flake. Today: Chrome! Specifically, sometimes clicking a link in end-to-end tests, even on a static page, doesn’t navigate to the next page. In the screenshot grabbed from the failing test it might even show the link as outlined as if it had been clicked. There was a period where roughly half of our builds were failing due to this issue, which, as you might imagine, can make you start questioning the value of end-to-end tests.

The Diagnosis

My understanding is that Chromedriver figures out where the element is, then clicks at those coordinates. If the layout shifts in that window, the click can land in the wrong spot. My best guess at what we saw: the mousedown landed on the link, focusing it, but by the mouseup the link had moved, so the two never registered as a real click. Chromedriver has a page on click issues, but it doesn’t seem to be a priority for them to fix.

The Fix

Switch to Firefox with Geckodriver. Maybe a bit cheeky, but that was our solution, and the amount of flake in our end-to-end tests plummeted. You might also consider checking out Cuprite if you’re in Ruby land, as it doesn’t use Chromedriver. There are a number of hackier alternatives, such as retrying the click or doing a JavaScript click() directly on the element, but I’d be concerned about those masking other issues.

React Lifecycle Edge Cases

2017-12-13T00:00:00-08:00

I have a “scratch” wrapper I wrote for React as an alternative to setState for controlled components. The idea being that it’s nice to keep all data in Redux, but it’s kind of a pain in the butt to do so manually for every single form, since generally you will also want that data to be cleared from the store when the form is unmounted. My ConnectWithScratch higher order component adds lifecycle hooks on component mount and unmount to create and delete scratch space for the component. As I’ve been using it, though, I’ve been discovering some interesting edge cases.

So my current ConnectWithScratch component calls createScratch in constructor with a user provided scratchKey. (I’m not going to share the current implementation with you because it’s a hairball and I’m still finding edge cases.) It passes an updateScratch prop down to the component to use. And it calls deleteScratch when the component unmounts. In one case I’m using my scratch component for an edit task form, where the scratch key might be something like editTask-114, where 114 is the task id. When I introduced this edit task form on another page, I ran into an interesting issue. The one on the new page has the same key, but when navigating from one page to the other, it tries to create the scratch for the new page before the old one has been removed. Console logging out revealed the following:

ShowView constructor // the new view is being rendered
ConnectWithScratch constructor:  editTask-114 // new view setting up scratch
creating scratch:  editTask-114 // so far so good...
FocusView componentWillUnmount // and the old view is about to unmount
ConnectWithScratch componentWillUnmount:  editTask-114 // old component scratch unmounting
deleting scratch:  editTask-114 // old component deletes the scratch space!!!
ConnectWithScratch componentDidMount:  editTask-114 // show view scratch mounted
ShowView componentDidMount // and the show view mounts, but has no scratch to work with

So, in short, React starts constructing the next component before the previous one is told it will be unmounted. Which maybe makes sense in terms of how React needs to work to reconcile and see if it can re-use anything. But it creates a pain point here. A few options that come to mind for me:

1) I might be able to move the createScratch call to componentDidMount. This will cause extra renders and maybe performance issues, per their docs, but the user won’t see any intermediary state. It also means we can’t touch the scratch space in the constructor.

2) I could assign each scratch component a unique id instead and use that as the scratch key, or part of it. This loses some of the benefit of the scratch space, though, in that we no longer have a readable key for debugging, nor can we rehydrate components in a straightforward way.

3) I could require the parent component to pass down a part of the scratch key that would make it unique, such as ShowView-editTask-114, FocusView-editTask-114. This maintains readability and rehydratability (sic), but adds additional complexity to actually using the scratch container. Now both the parent and the child need to know about the scratch component.

I don’t love any of these options, though I’m leaning towards option 1 for my first attempt at a fix. Option 2 is my last resort.

React Elm Wrapper

2017-11-28T00:00:00-08:00

I’ve recently been spending a lot of time scratching my head regarding application architecture with React and Redux. It often feels like this tug of war between class based and functional programming. I’m not super attached to one paradigm or another, but I am certainly FP-curious. However, whenever I push to work exclusively in a functional way in JavaScript, I keep running into situations where the code would be cleaner or more performant if I were doing it in a mutative or class based way. It feels like I’m trying to awkwardly shoehorn functional methods into a language that really wasn’t built for it.

Enter Elm

I’ve been hearing more and more about this language Elm and how happy people are on that side of the fence, so I decided it’s finally time to give it a shot. It’ll be a good opportunity to really immerse myself in functional programming, and even if I come away feeling it’s not for me, I should hopefully come back with some new wisdom and appreciation for the React ecosystem.

In React?

The first step along that route is figuring out whether and how Elm might actually integrate with React for an easier transition. It turns out it does, and the core maintainers of Elm built out a simple harness to make it easier. However, sadly, it hasn’t been updated in a while, so it doesn’t work with React version 16. There’s not that much code to it, so I’d be hesitant to add it as a dependency, anyway. So I brought the code up to date and plugged it into my application. Worked like a charm. Here’s the code:

import autobind from 'class-autobind';
import PropTypes from 'prop-types';
import React from 'react';

class ReactElmWrapper extends React.Component {
  constructor(props) {
    super(props);
    autobind(this);
  }

  componentDidMount() {
    const app = this.props.src.embed(this.node, this.props.flags);

    if (this.props.ports) { this.props.ports(app.ports); }
  }

  shouldComponentUpdate() {
    return false;
  }

  storeNode(node) {
    this.node = node;
  }

  render() {
    return <div ref={this.storeNode} />;
  }
}

ReactElmWrapper.propTypes = {
  flags: PropTypes.object,
  ports: PropTypes.func,
  src: PropTypes.object.isRequired,
};

export default ReactElmWrapper;

and you can use it like:

function MyReactComponent() {
  return <ReactElmWrapper src={SomeImportedElmApp} />;
}

See the “ground up” article below for a more in-depth example.

Links

I’ve found these to be really helpful, or hope to find them helpful in the near future:

Using Elm in React — from the ground up: This is a good place to start for setting up Elm with your application with configuration and a simple example project. Side note: if you’re running Rails, you can just run rails webpacker:install:elm to get things configured.
Elm SPA Example: A fully fleshed out Elm app with lots of great reference from nuts and bolts all the way up to application architecture.
Building A React/Redux/Elm Bridge: Haven’t dug into this one, yet, but looks like it’ll provide some solid insights around passing data back and forth.
Node Elm Compiler: Haven’t done anything with this, yet, but my JS tests are written in Jest, and I’d like them to continue working as I transition, so I think the code here may be useful along with Jest’s transform setting. If all goes well you’ll be seeing another blog post soon about how I managed with that.

Routes as State in React

2017-06-29T00:00:00-07:00

I’ve been using React Router for a while now in a project and was running up against some frustration getting access to information that comes through the URL. I’m using Redux and React Redux for state management and Reselect for getting useful bits of information out of the state. The problem is that when I need to grab some information from the state based on the current route, it can be really tricky to get all of the information I need in the right places. After a good deal of head scratching and soul searching, I realized that for my purposes, the routing information belongs in the state, not encoded implicitly in the components that are rendered.

The Lay of the Land

So I’m working on yet another todo list application. By default it shows you the next ordered task from your list, one at a time. When you select a tag, it should update the URL based on a url friendly “slug” for that tag (e.g.: /at-home), as well as showing the next task for that specific tag. Starting out, for this workflow, I was using React Router’s Link component and had a simple onClick handler that set the selected tag in the redux store:

function TagLink(props) {
  const { updateTagMeta, slug, name, id } = props;

  return (
    <Link to={`/${slug}`} onClick={() => updateTagMeta({ selectedTagId: id })}>
      {name}
    </Link>
  );
}

Routes looked something like:

<Provider store={appStore}>
  <BrowserRouter>
    <Switch>
      <Route exact path='/' component={TaskContainer} />
      <Route path='/sessions/new' component={SessionsNew} />
      <Route path='/tasks' component={TaskList} />
      <Route path='/:slug' component={TaskContainer} />
    </Switch>
  </BrowserRouter>
</Provider>

This all worked well and fine, as long as the user got to a tag by clicking on it. However, if the user used the URL to navigate to a tag (e.g.: by visiting /at-home) things didn’t work. There was no selectedTagId in the store so it ended up showing the next task from all of them. I had to find a way to get the currently selected tag into the state from the get go. When a user clicked the button, I set the selected tag id and also the slug in the URL, but when they went directly to that URL, I needed a way to derive the tag id from the slug already in the URL.

I considered a few options here. The first was to find a way to make use of the slug that was being parsed out by the Route component. It passed the matched URL elements down to the sub-components, so I could have added some lifecycle hooks to check for an updated slug and update the store accordingly. This didn’t feel quite right to me, though. I don’t like my components being too smart, and in this case it felt weird to have my sub-components doing the work of compensating for missing state that really ought to already be in the store. I briefly looked at React Router Redux, but the only thing it provides you is the entire route path, not the matched elements from the path, so with or without it, I’m left with the option of parsing the path myself, duplicating the work that is already being handled by the Route component. I could have written my own wrapper component, but when I am starting to write as much code to work around a library as it would take to roll my own, I start to think it’s time to build something more specific to my needs.

My Approach

In addition to the issue above, I’ve also had another nagging concern. I don’t like how tightly coupled the logic in my app is tied to the path in the URL. Much like one would fetch and persist data to a server, but store it locally in, say, a Redux store, it seems to me like we ought to do an initial “fetch” of the data from the URL, normalize it in a reasonable format for our client side, and hold onto it in our store. Likewise, when we update the information, we “persist” it to the URL, but continue to use our store as the source of data for our components. With all of this in mind, here’s what I came up with.

Routes

import pathToRegexp from 'path-to-regexp';

function compileRoutes(routes) {
  return routes.map((route) => {
    const regexp = pathToRegexp(route.path);

    return {
      ...route,

      match(path) {
        const result = regexp.exec(path);

        if (!result) { return null; }

        const params = {};

        regexp.keys.forEach((key, index) => {
          params[key.name] = result[index + 1];
        });

        return params;
      },

      toPath: pathToRegexp.compile(route.path),
    };
  });
}

const ROUTES = compileRoutes([
  {name: 'root', path: '/'},
  {name: 'sessionsNew', path: '/sessions/new'},
  {name: 'tasks', path: '/tasks'},
  {name: 'tag', path: '/:slug'},
]);

export default ROUTES;

Reducer

import ROUTES from 'src/route/routes';

export default function routeReducer(previousState, action) {
  if (action.type === 'route/SET') {
    const {name, ...params} = action.payload;
    const matchingRoute = ROUTES.find((route) => route.name === name);

    window.history.pushState(null, null, matchingRoute.toPath(params));

    return {name, params};
  } else if (action.type === 'route/INIT') {
    let params;

    const matchingRoute = ROUTES.find((route) => {
      params = route.match(window.location.pathname);

      return Boolean(params);
    });

    return {name: matchingRoute.name, params};
  }
};

Router Container

import {connect} from 'react-redux';

import Router from 'src/route/components/router';

function mapStateToProps(state) {
  return {route: state.route};
}

export default connect(mapStateToProps)(Router);

Router Component

import React from 'react';

import SessionsNew from 'src/session/components/new';
import TaskContainer from 'src/task/containers/item';
import TaskList from 'src/task/containers/list';

const ROUTE_NAME_TO_COMPONENT_MAP = {
  root: TaskContainer,
  sessionsNew: SessionsNew,
  tasks: TaskList,
  tag: TaskContainer,
};

export default function Router(props) {
  const Component = ROUTE_NAME_TO_COMPONENT_MAP[props.route.name];

  return <Component />;
};

Link Container

import {connect} from 'react-redux';

import Link from 'src/_common/components/link';
import {setRoute} from 'src/route/action_creators';

export default connect(null, {setRoute})(Link);

Link Component

import React from 'react';

import ROUTES from 'src/route/routes';

export default class Link extends React.Component {
  constructor(props) {
    super(props);
    this.navigate = this.navigate.bind(this);
  }

  navigate(event) {
    event.preventDefault();

    this.props.setRoute({name: this.props.to, ...this.props.params});
  }

  path() {
    const matchingRoute = ROUTES.find((route) => route.name === this.props.to);

    return matchingRoute.toPath(this.props.params);
  }

  render() {
    const {className, children} = this.props;

    return (
      <a href={this.path()} className={className} onClick={this.navigate}>
        {children}
      </a>
    );
  }
};

And the Tag Link from before becomes…

function TagLink(props) {
  const { slug, name } = props;

  return (
    <Link to='tag' params={{slug}}>
      {name}
    </Link>
  );
}

Epilogue

Et voila! The routing state is now in the store and accessible wherever we might need a bit of info about what is going on. I’ve also made it so that the routes are named. Some additional considerations:

A careful reader will notice that my reducer is no longer “pure” in that it has a side effect on the URL. This was again for the sake of readability, but I’ll probably end up moving that to an action creator.
I’m not accounting for the user pressing the back button, but that should be manageable if we subscribe to history POP events and simply reset the routing state from scratch.
I left off some additional error checking as an exercise for the reader (and again for readability), such as catching situations where a route does not exist and when the wrong parameters are passed for a route.
I started writing this article and came across this recent article from Free Code Camp exploring similar ideas, though they take a middleware approach to updating the browser history. Might be worth a glance if you’re looking for some alternatives. (And they’ve got more links for you at the end if you’re still not satiated!)

React DnD Example Simplified

2015-04-13T00:00:00-07:00

I recently started playing around with React DnD to implement some drag and drop sorting on an app I’m working on. The examples provided are built using a lot of the new syntax in ES6, as well as having a good deal of what might be considered more “proper” structuring for a React app, so it was challenging for me to parse out the critical bits for React DnD to function. To further my own understanding, I stripped out all of the ES6 syntax and some of the non-essential code in order to get the most basic drag and drop implementation up and running. Check it out below, as well as the original example for reference. This was built in the context of a rails app with react-rails and rails-assets-react-dnd, though I think the code should work readily outside of the rails context.

Setting up a Middleman Blog

2014-09-23T00:00:00-07:00

Second blog post seems like a good time to write about my experience setting up a blog using Middleman while it’s still fresh in my mind. Middleman is a static site generator, a la Jekyll, and I’m using their blogging extension. If you’re starting fresh, then I would recommend the thoughtbot post on how to get a blog set up with their bourbon, neat, and bitters SASS libraries, as this is somewhat an extension of their post. I’ll talk about setting up layouts, as well as coping with some minor styling issues I ran into.

The Issue

So coming away from the above thoughtbot blog post, I was pretty happy with the default styling provided by bitters, but one particular issue was that it removes the bullets and numbers from ordered and unordered lists. This makes sense in terms of the navigation, but inside my blog post I actually wanted to see them. Without putting straight up html in my markdown, my options for customizing the styling were limited. I spent probably well more time than I ought to have finagling the styling and structuring in my layout file only to find that the styling would work on the index page but not in the article view, or vice versa. Thus I went on the hunt for a saner option and found it in nested layouts.

Nested Layouts

Setting up nested layouts is pretty straightforward. Here’s one of those lovely bullet point lists:

create an articles directory and move your blog posts in there
create a layouts directory for your nested layouts
add a layout layouts/article_layout.html.erb
add the following configurations to config.rb
- blog.sources = 'articles/{year}-{month}-{day}-{title}.html'
- page '/articles/*', layout: :article_layout

And you should be set. Here’s what my article layout looks like:

<% wrap_layout :layout do %>
  <h3><%= link_to current_article.title, current_article %></h3>
  <h5><%= current_article.date.strftime('%b %d, %Y') %></h5>
  <article>
    <%= yield %>
  </article>
<% end %>

and my config.rb, minus the fluff:

activate :blog do |blog|
  blog.sources = 'articles/{year}-{month}-{day}-{title}.html'
  blog.tag_template = 'tag.html'
  blog.calendar_template = 'calendar.html'
end

activate :syntax, line_numbers: true
set :markdown_engine, :redcarpet
set :markdown, fenced_code_blocks: true

page '/feed.xml', layout: false
page '/articles/*', layout: :article_layout

set :css_dir, 'stylesheets'
set :js_dir, 'javascripts'
set :images_dir, 'images'
set :build_dir, 'tmp'

configure :build do
end

configure :development do
  activate :livereload
end

Styles

So there were a couple of styling issues I ran into. The first was the aforementioned missing bullets. I created a new partial stylesheets/partials/_article.css.scss:

article {
  ul {
    @extend %default-ul;
  }

  ol {
    li {
      margin: 0;
    }
    @extend %default-ol;
  }
}

You’ll need to add @import 'partials/article'; to all.css.scss after the bourbon includes.

One other issue is that the default bourbon styling on tables makes the line numbers in fenced code blocks take up half the page, so I also added this to _article.css.scss:

article {
  // ...other stuff you just added

  .highlight {
    table {
      width: auto;
    }
  }
}

And that just about covers it.

Errors

Here are a couple of errors and bugs I ran into, so if you see them, here’s how you can fix them. If you run into a build error, use middleman build --verbose to get the full output.

undefined method `title’ for nil:NilClass

You probably haven’t put your layout in it’s proper subdirectory. Move article_layout.html.erb into the layouts directory.

article not showing up

Make sure your article is in the articles subdirectory, and make sure you don’t have

published: false

in your front matter at the beginning of the post.

The selector “%default-ul” was not found.

It’s trying to precompile your scss partial stand alone. Double check that you have the _ in _article.css.scss.

Fin

That’s all. You can check out the full repo here, and the build that was referenced in this blog post here.

Finding an Apartment in San Francisco

2014-09-19T00:00:00-07:00

I recently settled into a new apartment after a grueling two month search, so I thought I’d share some of my experience looking for an apartment during the worst time of the year for it. It can be a harrowing time, and to be honest, if you can put it off until a better time of year, I’d recommend it. Prices will be lower and the competition for the affordable places will be considerably less fierce. Regardless of when you’re on the hunt, though, here are some tips that might help you get through it a little easier. What I share here is from the perspective of looking for a place to myself, but much of it should still apply if you’re looking for a roommate situation.

Know What You Want

When I started looking for a new place to live, it was easy to start rationalizing every place I went into and think “I could make this work”. I would spend my time applying and put in the application fee, and then a couple hours later realize that I didn’t really want it. Something that helped me to make a decision on a place before wasting too much time and money was to have a set of clear criteria that I could go over. My rule of thumb was that it had to meet all but one criteria, and some were more negotiable than others.

My criteria:

Bathtub
Not on the ground floor
Not in a sketchy area where I wouldn’t feel safe myself, or having my girlfriend walk
Room for all of my stuff and space to stretch out in between
Wood floors
Under $2000 ($2200 max fail)
Close to work, and the Mission

In this case I ended up compromising on the wood floors. To state the obvious, the higher you go on price, the less competition you’ll have, and better odds of satisfying all of your criteria. $2000 was actually kind of on the low end for my criteria, though I eventually found a place for a little less than that.

Be on the Ground

Most landlords won’t even consider you unless they can see your face. If you’re coming in from out of town, you’re going to have a much harder time finding a place unless you find your way to the city first. Expect to pay higher rent and get a lot more rejections. Landlords are on the watch for scammers, too, and for better or worse, one clear warning sign of a scam is that the person is out of town. Your best bet is to find some temporary accommodations in the city and look from there.

Papers, please!

When you go to a showing, typically they will have applications you can fill out, but it can become really tiring and discouraging to spend fifteen minutes apiece filling out one application after another. The California Apartment Association has an application that is pretty generally accepted. You can fill it out by hand and scan/copy it, or fill it out with a tool like Adobe Acrobat or Xournal. Aside from the application, different landlords and leasing agents will expect to see different documents. Here’s a list of documents I’d recommend keeping with you in a folder:

3 filled out copies of an application </input>
2 photocopies of your drivers license or other state ID </input>
1 copy of your full credit report (yes, there is the occasional landlord who wants the full 30+ page report) </input>
2 copies of your printed credit score (nothing fancy, just your name and a number from one of the three credit bureaus) </input>
checkbook (you’re unlikely to need to put down a deposit, but some require a rental application fee of around $50) </input>
2 copies of a reference letter from your previous landlord (you can find a form letter online to send to your landlord and ask them to sign) </input>
2 copies of your most recent 3 pay stubs </input>

The Hunt

Here’s where the rubber hits the road. Before we get started, I want to give you a little personal advice: don’t get attached. We all like to think we’re that one delicate and unique flower in the field that is somehow more precious than all the others, but keep in mind that there are probably a lot of qualified candidates applying for each of the units you’re visiting, some of whom have better credit scores. Like sales, apartment hunting is a numbers game. The more places you apply to (that meet your criteria, of course), the better your chances of getting something you like.

Padmapper

Padmapper was my power tool of choice during this hunt. In the past I always just used craigslist search and RSS feeds, but Padmapper makes it so much easier to find craigslist results in the areas that I want to live in and quickly filter them out. I’d recommend signing up for an account and setting up an email alert. My workflow went something like this:

open Padmapper
click open a link into a new tab
respond to the ad by their preferred means if I’m interested (or take a note to do so later)
close the tab
hide the result in Padmapper
repeat

And come back in another hour or two to start the process again…

Side note: I’d occasionally get gateway errors with Padmapper, so if you run into that you can clear your cookies and log back in. In Chrome you can click on the icon to the left of the url and click on “Show cookies and site data”, and remove them from there.

Responding

It’s important to respond to ads promptly, because often times the poster ends up inundated with responses and won’t be as likely to reply after the first few hours or so. You should still respond if you’re interested regardless, but your odds are better the earlier you do.

Some ads will want you to email, others call, and still others just want you to show up at the open house. If they have something marked as a preferred contact means under the “reply” menu, make sure to use that.

You can make responding less painful having a simple canned email that you can modify for each listing. Gmail has a Labs feature called Canned Responses that you can enable. In your email you should have:

the address you’re interested in
anything specifically asked for in the posting
3-4 sentences about you
how to contact you
I also like to paste in the craigslist link at the bottom for easy access

Here’s the message that I used:

RE: Elegant Studio - With full amenities

Hi there,

I saw your ad on Craigslist for a studio at Harrison at Main and the apartment sounds like a good fit for me. I'd love to come check it out if it's still available. When works best for you?

About me, if you're interested: I'm 33 years old and I work for a company that helps schools to minimize administrative costs, in particular by reducing paperwork. Sounds kind of boring, but it's having a huge impact. I bike a ton, climb some, and try to get outside and wander when I get a chance. I'm pretty quiet and clean, don't smoke or use drugs, and don't have any pets.

Anyway, so please let me know if there's anything else you'd like to know about me. If it's more convenient, you can call me at ^^^-^^^-^^^^.

Hope to hear from you,

- Robert

This will differ pretty dramatically if you’re looking for a roommate situation, since then it is much more important to express your personality and respond to the specifics of their posting. You can still have a canned email, but you’ll need to customize it a bit more.

Showing Up

Most people will suggest that you show up early for a listing. This is, in my experience, only true-ish. It depends on a lot of factors, and I would still recommend it for the most part, but it can depend on the situation. Some places go first-come, first-serve, many are looking for a pile of decent applications to choose from, and some are actually looking for a personality fit. For the most part I’ve found that showing up 15 minutes or so before the viewing can be helpful, since the person showing it is often there early, too, and you can sneak in before anybody else shows up. Other times you’re one of a mass of people who got the same idea, so your mileage may vary.

Be aware that landlords aren’t your friends. Schmoozing can be productive, but their top priorities are going to be looking for someone who is clean, quiet, and pays their bills on time. Those are the traits that you should focus on exhibiting, with likeability in a close fourth. Often times the person showing the apartment isn’t going to be the decision maker anyway, and your application will have to speak for itself.

Anatomy of a Scam

Whenever there are goods and services being exchanged for money, there will be people trying to scam both sides, and here is no exception. On the property side, scammers will often pose as potential renters who for one reason or another can’t come to see the property. Typically, they are after the bank account info of the landlord with the overt intention of transferring a deposit into it, and the subvert intention of draining it.

From the other side of things, scammers will try to get you to pay them without having any goods to deliver. They will list an apartment that is not on the market and give you excuses why you can’t see it. Either the tenant is out of town, or they already have a ton of applications and want you to get your chance, or it’s under renovation. They might tell you to drive by it and check it out from the outside. They’ll ask you to pay up front and emphasize that time is of the essence, and possibly try to tell you they think you’re the right person for the place, despite knowing nothing about you. A corollary to the bit above about landlords not being your friend is that if they sound like you’re friend, they’re almost certainly a scammer. Some even go so far as to offer you deals if you pay more up front, such as 10% discount for 6-months rent up front and 15% for a year.

Bottom line is, if it sounds too good to be true, it almost certainly is. Scammers will do what they can to try to look legitimate. They will copy images and descriptions from other postings and websites. They might impersonate a real person, using “brian.smith@yahoo.com” when there is a real “brian.smith@somerealtyco.com”. They might even be so bold as to copy a listing with an open house that is still available. You go to the open house, like it, and then pay the scammer instead of the real owner. When in doubt, make sure you see the face of the person you’re in touch with.

Additional Thoughts

There’s still a lot I could add to this, but I think I’ve shared the most important parts. A couple of final bits of advice, though.

First off, iterate. I spent a little time every day looking over my application and the process I was using, and it was surprising to find there was always something that could use a bit more tuning, whether it be on my application or my presentation. I even went so far as to get my shaggy hair trimmed up a bit to look more presentable.

A second thought is to ask for feedback. People showing apartments are going to be pretty busy and overwhelmed, but there might be a window from time to time where you can ask them what they’re looking for and if there are any red flags on your application.

If you’d like a bit more reading, here’s another article I found useful when I started my search. Best of luck!