Loading...

Follow Hired.com Candidate blog on Feedspot

Continue with Google
Continue with Facebook
Or

Valid


When I joined Hired about 3 years ago, we basically had a Home page, About page, and not much else.  Recently we’ve decided to dig deeper into SEO and renew our focus on driving organic traffic.

This whole time, I’ve wanted to work on SEO to leverage all of the content we have in a way that would allow us to reach candidates and employers searching for jobs or candidates matching certain criteria. We have tens of thousands of companies on our platform and an order of magnitude more jobs in our database, so we needed to come up with a way to leverage that data. 

Looking at the way people search, we decided to start down a path of figuring out how to programmatically build new pages to target searches like “ruby on rails jobs san francisco” or “biotech companies in austin”.   We could have gone with a search-like product where filters could be applied as parameters like /jobs?city_id=1&industry_id=2, but those urls would be worthless for SEO purposes.  We wanted to generate and open up landing pages with urls like /jobs/san-francisco/biotech.

The MVP

When we first began building these pages as an MVP, we started with the most simple version possible: a few lines in the routes file, some constraints, a few new actions, and a bunch of duplicated code.  Here’s a basic example:

First we’d add a route:

# config/routes.rb
…
get '/jobs/:id', to: 'jobs#city_directory', constraints: CityConstraint.new

# lib/constraints/city_constraint.rb
class CityConstraint
 def matches?(request)
   HIRED_CITY_SLUGS.include?(request.params[:id])
 end
end

Then in our controller

# app/controllers/jobs_controller.rb
def city_directory
 city = City.find_by(slug: params[:id[)
 Job.find_by(city: city.name)

Pretty straightforward right?

Adding More Pages Unsustainably

Once we had a basic idea of how these might perform, we decided to go further by adding more top level filters, like state, region, category, industry, required skills, role, and more.  So to do that, we started off going the easy route: copy+paste! 

All of a sudden our routes file started to look like this:

# config/routes.rb
…
get '/jobs/:id', to: 'jobs#city_directory', constraints: CityConstraint.new
get '/jobs/:id', to: 'jobs#state_directory', constraints: StateConstraint.new
get '/jobs/:id', to: 'jobs#industry_directory', constraints: IndustryConstraint.new
# [ad infinitum]

This started to look worse when we decided to also filter companies as well, duplicating each line for companies and jobs… The controllers were looking even worse than the routes as we’d create a new action for each filter and write lookup code for each filter combination 

def companies_by_role_and_industry… etc

AND we needed to create a new constraint for every single combination… There was duplication everywhere!  Yikes!

It Gets Worse

Things were already looking messy enough, but then we decided we wanted to build pages with nested filtering like [Find Backend Engineer Jobs at Gaming Companies in San Francisco](https://hired.com/jobs/san-francisco-ca/gaming/backend-engineer)… Did we really need to manually add routes and a controller action for every combination?  What about nested filters?  Something like

get ‘/jobs/:id/:industry/:role'

started to provide more and more problems.  This was clearly no good.

Rethinking What We’re Doing

So I decided to re-evaluate what our SEO pages were actually doing:  basically all we wanted to do is take a resource like Job, apply some set of arbitrary filters matching a url pattern like city/industry, and display those with some custom copy here and there for the filter pair, exposing the urls in our sitemap. 

So I started by defining a list of url patterns that effectively would also define the filters:

class SeoFinder
 def initialize(base_scope, filters={})
   @scope      = base_scope
   @filters    = filters
   process_filters! if @filters.present?
 end

 # parse out the filters and apply them with a little meta programming
 def process_filters!
   @filters.slice(*self.class::ENABLED_FILTERS).each do |filter, value|
     send(:"filter_by_#{ filter }!", value)
   end
 end

 def filter_by_city!(city_slug)
   city = City.find_by(slug: city_slug)
   @scope = @scope.where(city_id: city.id)

   @scope.lazy
 end

 # etc for each type of filter we want, just make sure the queries are uniform across the models you would supply here, which is a great case for adding uniform named scopes!

 private

 # we can delegate or use method missing to make sure the finder behaves like an AR::Relation

 def method_missing(name, *args, &block)
   if scope.respond_to?(name)
     @scope.send(name, *args, &block)
   else
     super
   end
 end
end

Now in our controller method, we just need to forward the request parameters which contain our filters:

# app/controllers/jobs_controller.rb
 def directory
   @jobs = SeoFinder.new(Job.active, params)
 end

Voila!

With this approach, we can now create tons of pages by adding a new pattern to the

/lib/seo_routes.rb

file.  If you think about a pattern like

/:market/:industry/:role

and consider we have 16 markets, 43 industries, and 44 roles, just adding this single pattern generates 30,272 new pages!!

Some Notes

Obviously the code shown above is simplified.  In the controller, we also do some stuff like setting instance variable names, and interpolating the variable names into I18n calls to set the meta descriptions and titles and headers, etc.  We can also use the PATTERNS list to iterate across all the matching records to build our sitemap pretty easily.

The post Deploying Hundreds of Thousands of SEO Pages with a Few Lines of Code in Rails appeared first on Career Advice.

Read Full Article
Visit website
  • Show original
  • .
  • Share
  • .
  • Favorite
  • .
  • Email
  • .
  • Add Tags 

Ruby on Rails servers are a little infamous for having a slow response times. It’s not uncommon for a Rails application to take upwards of 3 seconds to respond to an HTTP request. Some of this slowdown is unavoidable and caused by the additional overhead of running a web server in an interpreted language such as Ruby. But there can be other more controllable factors that may be contributing to slowdown.

As a Rails app matures, controllers can be become slow as more and more has to happen per HTTP request. At Hired, we solved this problem using a pub/sub implementation we call Reactor.

Without Reactor

Consider a model named User:

# app/models/user.rb
class User < ApplicationRecord
  # ...
end

When a

User
record gets created, we’ll want to send the user a welcome email. Under the hood, Rails will make at least one, possible HTTP requests to send the email.
# app/mailers/user_mailer.rb
class UserMailer < ApplicationMailer
  default from: 'notifications@example.com'

  def welcome_email(user)
    @user = user
    @url = 'http://example.com/login'
    mail(to: @user.email, subject: 'Welcome to My Awesome Site')
  end
end

We also want to sync information about the User to Salesforce, the CRM of choice for our sales team. The actual Ruby implementation of this syncing process isn’t pertinent, but it’s worth noting that the syncing process requires making an external web service call to Saleforce’s API, an operation that can take multiple seconds. It also blocks our server from responding to the

User
being created until the sync with Salesforce has completed.
# app/services/salesforce_service.rb
class SalesforceService
  def initialize(user)
    @user = user
  end

  def create_or_update_user!
    # code that communicates with API
    # ...
  end
end

# app/controllers/users_controller.rb
class UsersController &lt; ApplicationController
  # POST /users
  def create
    @user = User.create!(params[:user])

    UserMailer.welcome_email(@user).deliver
    SalesforceService.new(@user).create_or_update_user!

    render json: @user, status: :created    
  end
end

To actually create new

User
s, we have created the
UsersController
. When someone wants to sign up for an account on our service, they send a POST request to
/users
to create an account. Before our server can send a response to the server, it must complete
UserMailer.welcome_email(@user).deliver
and
SalesforceService.new(@user).create_or_update_user!
. These synchronous methods take a while to run.

This implementation will work, but it’s slow. Internet users hate slow websites. Fortunately, with the help of a tool we built called Reactor and some small refactoring, we can speed up this process and keep our users happy.

Reactor

Reactor is Hired’s in-house implementation of a pub/sub framework. It is not the only Ruby pub/sub framework in existence. There are plenty of others. When we began working on Reactor in 2013, there were no other open-source pub/sub implementations for Ruby.

Pub/sub is short for publisher/subscriber. It’s a design pattern for applications where data producers (publishers) push data to a messaging queue. Workers monitor this queue, looking for events that they are subscribed to, and when a match is found, they perform an action in response.

Reactor provides us with a really nice API for firing events in a variety of contexts, writing these events into a Redis queue, and subscribing to these events with background workers.

Events in Reactor can have fields with any name, but there are a few standard fields that all Reactor events share.

  • actor
    – required – the record firing the event
  • target
    – optional – the intended recipient of the event.

To add Reactor to our project we just add:

gem 'reactor'

to our Gemfile and in our shell execute:

bundle

Now that Reactor is installed all we need to do is call

publish :some_event
on an instance of
ActiveRecord::Base
to fire an event with that record as the
actor
.

We can now remove the long-running method-calls from

UsersController#create
. Instead, we use Reactor to handle our communication with Salesforce and send the user a welcome email asynchronously. Using Reactor in our App

# app/controllers/users_controller.rb
-    UserMailer.welcome_email(@user).deliver
-    SalesforceService.new(@user).create_or_update_user!
+    @user.publish :user_created

Instead of performing the slow actions, we just publish a Reactor event and rely on subscribers running elsewhere to notice our event and take an action.

The welcome email is handled by the brand-new

UserMailSubscriber
:
# app/subscribers/user_mail_subscriber.rb
class UserMailSubscriber
  include Reactor::Subscribable

  on_event :user_created do |event|
    user = event.actor
    UserMailer.welcome_email(user).deliver
  end
end

By calling

on_event :user_created
, we are telling the
UserMailSubscriber
to listen for any
:user_created
events fired in the application and to pass the provided block the data of the events. In the example above, the provided block sends the welcome email. We use the same pattern for Saleforce synchronization:
# app/subscribers/salesforce_subscriber.rb
class SalesforceSubscriber
  include Reactor::Subscribable

  on_event :user_created do |event|
    user = event.actor
    SalesforceService.new(user).create_or_update_user!
  end
end

One of the nice things about Reactor is that both of these subscribers listen for the same

:user_created
event type, but won’t preempt each other from executing. Both subscribers receive the event.

Now that we’ve refactored our application code to use the Reactor framework, POST requests to

/users
should be much quicker. Calls to this endpoint will schedule work to be done offline with Reactor rather than completing it within the request. Reactor is Pub/Sub

Using pub/sub lets us build an ecosystem of events and responses. In our example,

User
is now a publisher. It lets subscribers know that it has been created by firing a
:user_created
event within
UsersController#create
. The event is immediately added to a Redis queue.
UserMailSubscriber
and
SalesforceSubscriber
, running on our Sidekiq instances, receive the
:user_created
event and perform their specified work.

There are a number of benefits that using a pub/sub pattern provides us beyond performance improvements. Subscribers don’t need to communicate with publishers directly or synchronously because the all events are passed through a messaging queue.

Pub/sub also loosely couples the subscriber and publisher logic. As long as the publisher can write to the messaging queue and subscribers can read from it. The publisher and subscriber don’t need to be implemented in the same programming language. Another advantage is when we want to make changes to the code of a subscriber, we don’t need to change the publisher.

Pub/sub is also scalable. The number of instances of publishers or subscribers can increase or decrease as long as the messaging queue remains intact. Different publishers and subscribers can be implemented but still use the same events, if it’s appropriate. For example, both

UserMailSubscriber
and
SalesforceSubscriber
subscribe to the
:user_created
event.

Reactor has enabled us to scale our application and serve more people while relying on Sidekiq’s rock-solid core infrastructure. Come work with us!

The post Hired Eng: Scalable Features with Rails and Reactor appeared first on Career Advice.

Read Full Article
Visit website
  • Show original
  • .
  • Share
  • .
  • Favorite
  • .
  • Email
  • .
  • Add Tags 

When it comes to recruiting for tech jobs, you only need to know one word: engineering.

New data from Hired found that, while product manager salaries may be higher on average, companies want to hire more engineers than employees in any other role—by a wide margin. In fact, the top five most requested positions by companies are all engineering positions. Here are the top five most in-demand tech roles:

  1. Full Stack Engineer
  2. Backend Engineer
  3. Frontend Engineer
  4. DevOps Engineer
  5. Mobile Engineer
The fuller the stack…

It comes as no surprise that companies are most interested in hiring full stack engineers, as these swiss army knife developers are familiar with all layers of development and can thus adapt as a company’s needs evolve. Luckily, full stack web development is also the most popular developer occupation, with the 2017 Stack Overflow Developer Survey finding more than 70% of respondents to be web developers (as opposed to mobile, app, or other types of specialist roles), and 6 in 10 of those 70% to be full stack developers.

Backend engineers come in second on the list, and were also the second most common type of web developers in the Stack Overflow survey. While backend developers are a step removed from what the company’s users actually see, their work is crucial as it delivers the underlying technology necessary for a smooth user experience.

Frontend, DevOps, and Mobile Engineers fill the last three top spots on the list, but that doesn’t necessarily mean that they’re less valued—but likely that there are simply fewer of these roles to fill. The fact that DevOps engineers—skilled developers who automate software delivery and infrastructure—hold the number four spot (overtaking product management, data analytics, and design roles), suggests there to be significant demand for even the more specialized software roles.

High demand bodes well for wages

The average salary for software engineers included in this study in 2017 was found to be $137K. This is up nearly 5% from $131K in 2016, and more than 6% from $129K in 2015.

Compared with national salary figures, software engineers (and, frankly, most tech workers) are in a great place. The global average salary for tech roles in software engineering, data analytics, product management, and design was found to be $135K, while the median U.S. income in 2017 for those with a Bachelor’s degree or higher was reported to be just $61,440.

According to our data, software engineers and data analytics professionals make around the same amount, both earning an average of $137K in 2017 and similarly close salaries in previous years. Design salaries are around $10K lower, coming in at $127K according to the most recent data. Product managers, on the other hand, have seen great growth in recent years, having earned less than both software engineers and data analysts in 2015, but claiming the highest average salaries in 2016 and 2017.

Double down on these skills

If you’re hoping to earn one of these top salaries yourself, you’ll need to be sure your engineering skills are up to snuff—and that you’re well-versed on the programming languages that companies value most highly. Our marketplace data ranks the following tech skills as most in demand right now:

  1. JavaScript
  2. Java
  3. Python
  4. HTML
  5. CSS

While it can be tempting to spend your time on more “trendy” programming languages—and likely a good exercise if you’re comfortable with the classics—keep in mind that most companies are more interested in your mastery of these old(er) standards.

All tech jobs are not equal

If our latest data proves anything, it’s that there’s a good degree of heterogeneity across career types—even within technical roles at tech companies. Unsurprisingly, virtually every type of software engineering role is more highly demanded by companies than any other position, including product management, data, and design.

So if you’re a software engineer, take heart in the fact that your job prospects are looking great, at least in the next few years—and if you’re thinking of getting into engineering, rest assured that you’ll have job offers aplenty if you can successfully demonstrate your software expertise.

The post Why These 5 Engineering Roles are Most In Demand in 2018 appeared first on Career Advice.

Read Full Article
Visit website
  • Show original
  • .
  • Share
  • .
  • Favorite
  • .
  • Email
  • .
  • Add Tags 

Looking for your next tech job? If sheer dollar amount is your top priority, avoid tech jobs in San Diego—and (surprise!) shoot for a career in the San Francisco Bay Area.

New proprietary data from Hired, including more than 420,000 interview requests across 69,000 job seekers, sheds light on what tech workers in roles including software engineering, data analytics, design, and product management, make in 10 different cities across the U.S, as well as in 3 international hubs. Read on to see how your salary (and city) stacks up.

Bay Area is still king, but others are catching up

Tech salaries in the Bay Area top the charts for the third year in a row, coming in at an average of $142K in 2017. That’s 5% more than in 2016—the same growth rate as seen for tech salaries globally. But with an average monthly cost of living of more than $1,000 in San Francisco, other cities might be just as, if not more, desirable for your next tech job.

Both Los Angeles and Austin, for example, have seen steady salary growth in recent years, with the average salary in both cities increasing by more than 9% since 2015. New York and Seattle have also experienced upward trending salaries since 2015, but to a lesser extent. This trend could continue, particularly if more companies, both large and small, decide to relocate or add additional offices in these cities.

The story isn’t so positive across the board, however, with cities like London, Washington, DC, and Boston experiencing a net decrease in average income since 2015. Of course, that’s not the whole story—DC, for example, saw 6% growth from $109K to $116K between 2016 and 2017, but that’s from a high of $121K in 2015.

From a pure numbers perspective, the Bay Area is followed by Seattle, with an average tech salary of $132K, while New York and Los Angeles tie for third place at $129K. Here is a ranking based on average tech salary (including roles in software engineering, data analytics, design, and product management) of all 13 cities analyzed in this study:

  1. SF Bay Area ($142K)
  2. Seattle ($132K)
  3. Los Angeles ($129K)
  4. New York ($129K)
  5. Austin ($118K)
  6. Boston ($118K)
  7. Washington, DC ($116K)
  8. Chicago ($113K)
  9. Denver ($112K)
  10. San Diego ($108K)
  11. London (£58K, or $78K at the time of writing)
  12. Toronto ($92K CAD, or $73K at the time of writing)
  13. Paris (€48K, or $56K at the time of writing)
Cost of living shouldn’t be overlooked

While an eye-popping salary number can be exciting, the cost of living can be a sobering reality in some of the more tech expensive cities across the country.

To account for this variability, we adjusted the above rankings for cost of living—that is, we calculated how much each city’s average salary would be worth if the cost of living were the same as in San Francisco. This ranking looks a bit different, with the SF Bay Area falling to the #10 spot:

  1. Austin ($202K)
  2. Los Angeles ($182K)
  3. Seattle ($182K)
  4. Denver ($177K)
  5. Chicago ($173K)
  6. San Diego ($166K)
  7. Toronto ($202K CAD, or $157K at the time of writing)
  8. Boston ($150K)
  9. Washington, DC ($148K)
  10. SF Bay Area ($142K)
  11. New York ($136K)
  12. London (£75K, or $100K at the time of writing)
  13. Paris (€72K, or $85K at the time of writing)

Other cities known for high living costs, such as New York and Washington, DC, also shake out lower on this list, leaving room for up-and-coming tech hubs to land the top spots.

These high living costs are affecting how tech workers think about where to live, and where they might move. We asked over 700 techies who got a job on Hired where they find most appealing for relocation… their answer? Seattle (#1) and Austin (#2). Still further, 4 in 10 tech workers said they did not feel they were compensated fairly based on the cost of living in their city.

So while the epicenter of tech may remain in Silicon Valley for the foreseeable future, keep an eye on lower cost-of-living, high growth cities—whether you’re an employee looking for a new job, or a company considering a relocation or second office.

The post Here’s a List of Average Tech Salaries Across the Country appeared first on Career Advice.

Read Full Article
Visit website
  • Show original
  • .
  • Share
  • .
  • Favorite
  • .
  • Email
  • .
  • Add Tags 

In a job market where employers are in tough competition for talent, it’s no surprise that tech companies have risen to the challenge by offering generous salaries. And there’s no doubt that technical skills are a huge asset to employees, with a new study finding the global average salary for tech workers in software engineering, design, product management, and data analytics to be $135K in 2017.

By comparison, the median personal income for workers with a Bachelor’s degree in the U.S. in 2017 was just $56,592. Even those with a professional degree earned less than the average tech worker, taking home $91,538 last year. Here, we’ll dive into how tech salaries break down for various roles, including an analysis of how that’s changed in recent years.

Most technical not necessarily the highest paid

Even within the tech industry, there are significant salary differences to note.

Perhaps surprisingly, this study found that both software engineers and those in data analytics roles—often thought of as the highest-paid of tech workers—came in second to product managers in terms of average salary in 2017. Product manager salaries topped the charts at $145K, $10K above the global tech salary average and up a whopping 14% since 2015.

Roles in software engineering and data analytics were found to pay an average of $137K in 2017, just above the global average and nearly 6% less than the average product manager salary. Both types of roles also saw less growth over the past two years compared to product manager roles.

Software engineering salaries were found to have grown just 6% since 2015, and an average of only $6K between 2016 and 2017. Further, data analytics salaries have grown only 3% since 2015, and actually declined slightly between 2015 and 2016.

Designer salaries growing, but still catching up to more technical roles

The study found the average design salary in 2017 to be $127K, a full $10K less than data analytics and software engineering roles. But while design salaries were stable between 2015 and 2016 at $118K, the average grew nearly 8% between 2016 and 2017 .

In fact, design salaries grew at a faster rate in 2017 than any other technical roles analyzed in this study. If this upward trend continues, designers may soon earn just as much as their more technical counterparts—a promising prospect for designers across the world.

Software engineers still in highest demand

Despite not being the top earners in this analysis, software engineers are by far the most in-demand candidates amongst tech companies. In fact, when ranked by the most requested positions, software roles make up all five of the top slots, suggesting that—even if average salaries are higher for product managers—engineering candidates have a significant amount of leverage when negotiating their salaries.

As you might expect based on the above data, the top five in-demand tech skills are all programming languages, including JavaScript, Java, Python, HTML, and CSS. Despite hundreds of programming languages out there, the data suggests that it’s these old(er) standards that tech companies still hold most highly when evaluating potential employees.

Don’t switch careers tomorrow

If you’re a tech worker in a (comparatively) lower-paying role, that doesn’t necessarily mean you should be targeting a product management role for your next job. It’s important to keep in mind that salary is only one factor in job satisfaction, so don’t be swayed toward a higher (average) salary if you’re already happy with your role—and remember that average numbers don’t tell the whole story, so there’s a good change you could earn more than that.

On the other hand, if you’re new to the job market or looking to change roles, potential salaries coupled with in-demand skills can certainly help to evaluate which career path might be the best for you based on your goals. Again, it’s just one factor to juggle against many others, but it’s worth looking into before making your decision.

The post Data Reveals the Top 3 Highest Paid Jobs in Tech appeared first on Career Advice.

Read Full Article
Visit website
  • Show original
  • .
  • Share
  • .
  • Favorite
  • .
  • Email
  • .
  • Add Tags 

If you’re a tech worker looking for a change of pace—but not willing to make sacrifices when it comes to salary—your options are quickly expanding to include more than traditional tech hubs like the SF Bay Area and New York.  While average tech salaries in the Bay Area still top the charts, there are other important factors to consider, such as how quickly salaries are growing in different locations, not to mention cost of living differences that make your earnings go further (or, in some cases, less far) in some cities.

Specifically, one new analysis reveals that tech salaries (for roles in software engineering, design, product management, and data analytics) in Seattle, Austin, and Washington, DC are increasing at a faster rate than in any other cities included in the dataset. In this article we’ll dive into what those differences look like, and what that might mean looking towards the future.

Average earnings don’t tell the whole story

Our data found that, on an aggregate level, Bay Area-based tech workers still make the most per year, with an average salary of $142K in 2017, as compared to a global average of $135K. Seattle came in second at $132K, and tech workers in New York and Los Angeles earned the same average salary of $129K.

But these are just average salaries at one point in time, which don’t reflect where the various cities have come from—and therefore the upward (or downward) trajectory they’re on. To dig further into this, we also analyzed salary growth between 2016 and 2017 for each city.

Austin was the clear winner in this analysis, with average tech salaries growing more than 7% from 2016 to 2017, from $110K to $118K. Los Angeles and Washington, D.C came in close second, both seeing salaries grow an average of 6%. On a global level, tech salaries grew by 5%—incidentally, the same rate that the Bay Area saw in the same time period.

Surprisingly, some popular cities saw wage stagnation, or even declining salaries, between 2016 and 2017. Boston, for example, held steady with an average tech salary of $118K, whereas salaries in Denver fell from $114K to $112K. Salaries in international tech hubs, like London and Paris, were found to be significantly lower on average; $77K and $57K, respectively, in 2017.

Still further, comparing salaries across cities is a bit like comparing apples to oranges, as living costs vary significantly between the geographies analyzed—and each dollar therefore has a different value in each city. For example, while the Bay Area boasts the highest average salary, the cost of living there is also one of the highest, meaning that each dollar earned in San Francisco buys less than it would in a city such as Austin, for example. To account for this, we ran a comparison by adjusting salaries for San Francisco cost of living—that is, we asked how much each salary would be worth if every city had the same cost of living as San Francisco.

Under this analysis, Austin again came out on top, with an adjusted salary of $202K, followed by Los Angeles and Seattle at $182K. In the U.S., San Francisco and New York fared the worst, with respective adjusted salaries of $142K and $136K—not all that surprising given countless news headlines about rent and other astronomical expenses in both cities.

So, where should your next tech job be?

As with many things in life, it really depends on what you’re looking for.

If you’re keen to try out an up-and-coming city with great potential upside, you might consider cities where salaries have been growing in recent years, such as Seattle, Austin, and Washington, D.C. In addition to being part of a newer startup scene, these cities may offer better growth potential than some of the more established tech cities.

Another important factor to consider is cost of living across cities, as this can significantly impact your purchasing power—and while a salary may look lower at face value, a lower cost of living might increase the relative attractiveness of one city over another.
Geography is just one (important!) consideration as you think about your next tech job, but there are many other factors that affect who gets paid what. Check out Hired’s 2018 State of Salaries Report for a full analysis of tech salaries in 2017 and beyond.

The post Top 3 Cities to Find Your Next Tech Job appeared first on Career Advice.

Read Full Article
Visit website
  • Show original
  • .
  • Share
  • .
  • Favorite
  • .
  • Email
  • .
  • Add Tags 

Like many other critical business functions, machine learning is slowly creeping into HR departments. The buzz of machine learning has some people thinking that it could eliminate all of our jobs, while it has others thinking it could be the next big wave of productivity. The truth is, one won’t replace the other — technology and people will ultimately need to co-exist because machines can’t do it all.

For example, in a recent Talk Talent to Me podcast episode, Cat Surane and Luke Beseda at Talent Partners for Lightspeed Ventures discussed the importance of understanding a candidate’s motivations for pursuing a new job — are they just looking for a higher salary? Are they using your job offer as a bargaining chip with their current employer? Machines aren’t good at evaluating the emotions driving a job search; you need a human to do that.

With that said, machine learning can do a lot to make recruiting more efficient, which is desperately needed given that it takes 43 hours on average to recruit one engineer.

Here’s what machine learning should do:
  • Provide recommendations. Today, the majority of HR professionals leveraging recruitment platforms are sourcing talent via a search based system where profiles are surfaced based on factors such as location, skills, experience and industry. Since this doesn’t take into consideration whether or not the candidate will be a good culture fit, it actually ends up making the process more challenging. That’s where machine learning comes in, shifting hiring tools from a sourcing method to a recommendations paradigm. Instead of sifting through a list of 500 candidates, job and networking sites can use machine learning to intelligently suggest candidates who have the right qualifications for the specific open role. Technological developments that provide deeper visibility into the candidate pool help job seekers and recruiters use their time more efficiently to find the best job fit, which is exactly what machine learning should be doing for recruiting.
  • Understand unstated goals. Classic job descriptions have long been criticized for being too generic or all-encompassing. Machine learning can help by uncovering candidates that match an organization’s unstated goals, such as improving workforce diversity. When unstated factors are known, HR teams reap the benefits due to high-powered search capabilities that identify tailored candidate matches.
    Machine learning can also play a major role in addressing tech’s gender wage gap. For example, it can source and analyze salary data to help companies understand what they should be offering candidates, based on their specific skills and experience, not their previous salary.
Machine learning shouldn’t:
  • Bias against diversity. Organizations that are considering using machine learning to improve their hiring process will likely find that building an equitable platform, free of unbiased hiring and wage gaps, will be the biggest challenge that they face. When employing machine learning, organizations need to ensure that the dataset being used to train the algorithm is normalized to remove all biases.
    Normalizing data means adjusting values measured on different scales to a common scale. Lets use an example to understand this. If we have 1000 candidates in our dataset — 800 men and 200 women — and this data is used to determine who will have a successful outcome, the algorithm is going to most likely predict men having successful outcomes, just because the volume of men in this dataset is far greater than women. Normalizing this data means taking 200 women and 200 men and using this normalized dataset to build the algorithm. This is critical for the tech hiring industry in particular because if you have more volumes of inherent data in an algorithm then the algorithm will be biased; i.e., if we were to not normalize that data, over time women wouldn’t even make it onto the platform.

There’s more that goes into whether or not someone accepts a job or is suited for a particular role than what can be analyzed in a system. At a recent SourceCon, Glen Cathey talked about where technology can’t replace humans. Cathey claims that anything that falls under the umbrella of context, nuance, or empathy should not be threatened by AI.

Trust is another important factor. Accepting a job offer is a hugely personal and important decision, and having a machine manage the entire process doesn’t fill a person with trust. Human interaction ensures candidates feel that their priorities, whether it a salary request or a concern about team structure, are being clearly communicated and considered.

Organizations that will be successful with leveraging machine learning in hiring are the ones that use it to advance productivity, not do their job for them. To fix the broken process recruiters will need to add value during the interview prep, offer assistance with negotiations and continue to be an advocate for both parties involved. At the end of the day, humans and algorithms need to work together, and if leveraged correctly, machine learning will give an immediate boost to the industry.

The post Will Machine Learning Eliminate Your Job or Help You Find the Right One? appeared first on Career Advice.

Read Full Article
Visit website
  • Show original
  • .
  • Share
  • .
  • Favorite
  • .
  • Email
  • .
  • Add Tags 

Technical interviews can be daunting, whether you’re early in your career or a seasoned engineer. While the most important piece of these interviews is, of course, your technical skills, there are a number of things you can do to prepare beforehand, ensuring that you have a clear mind going in and allowing these skills to shine through.

Before the interview

Know your story
No matter how technical a role you’re going for, companies want to hire people who work well with others—and the ability to communicate clearly and concisely is a key skill in working with teams. Interviewers will be evaluating your communication skills when they ask less technical questions, so be prepared to speak about your past work experience and education coherently, based on what is on your resume. Try practicing this pitch alone or to a friend beforehand to make sure it sounds the same out loud as it does in your head.

Further, being able to describe the specific projects you’ve worked on in detail is crucial, particularly if you have a bit of work experience under your belt. Describing how you’ve solved difficult problems in the past, especially if they are similar to problems that the hiring organization might be facing, can give you a huge leg up in a technical interview.

Study your data structures and algorithms
Like it or not, classic data structures and algorithms interview questions—often assessed on a whiteboard—are here to stay. Linked lists, arrays, queues, binary trees, graphs, and even slightly more obscure data structures like tries and bloom filters are worth knowing inside and out. Make sure to know the running times associated with common operations on each data structure, and scenarios in which they are likely to be used.

With your data structures knowledge in hand, take some time to understand the most commonly used algorithms. Techniques such as divide and conquer, graph traversal, and even dynamic programming are must-know material if you want to ensure top performance in a technical interview.

Practice example problems
While having the concepts in your head is a great start, there is no replacement for practice. There are a plethora of practice problems available on sites like HackerRank, Quora, and HackerNews. Working through these problems will develop your ability to understand problems quickly as well as to apply the techniques studied in your data structures and algorithms review to construct efficient solutions.

The phone screen is a good opportunity to get a better grasp on the types of questions that might come up in your onsite, so be sure to ask questions—particularly related to the projects the team is working on and where you might be expected to add value—early on in the interview process. The more specific you can be about which types of problems to practice, the better prepared you’ll be in the actual onsite.

On the flip side, remember that you’re interviewing the company just as much as they’re interviewing you, so getting an idea of what you’ll be doing (and practicing example problems that might mirror the actual work) can help you evaluate whether you’ll be happy in the role. According to our latest Brand Health Report, technical workers considering a new job are most concerned with the products and projects they might work on, so it’s beneficial to both parties for you to have a good sense of what the role will entail—and your ability to deliver on said projects.

Know your interviewer(s)
Figuring out some details about who your interviewer(s) will be can help you better prepare for your onsite, both in terms of predicting the types of questions that will be asked and knowing how to frame your answers. Some recruiters or hiring managers will be explicit about your interviewer panel. If not, there’s no shame in asking—or do some digging online and take your best guess at who will be on the other side of the table.

Once you have an idea of who your interviewer(s) will be, look at their accounts on GitHub, LinkedIn, etc. to get a sense of projects they’ve worked on, their interests, and their past roles. Make a note of specific skills they might help you learn (joining any team should be mutually beneficial!), as well as gaps in their expertise where you might be able to add to the team.

During the interview

Make yourself comfortable
Stay hydrated and have a snack or a coffee if you need during the interview, as there’s no reason to add physical stress to a mentally exhausting exercise. If the interview involves coding on a computer, make sure to take your time assessing and checking out the environment on the test machine before diving into the task at hand.

Ask questions and think out loud
Make sure to understand each question fully—specifically, the types of any inputs and limits on their size or complexity—before getting to work on your solution. For example, if asked to search for an item in array, it is important to know whether or not that array is already sorted.

Don’t be afraid to ask your interviewer questions. Having made it to the technical onsite, the company is investing time and resources into interviewing you, so it’s in their best interest to help you perform well—and interviewers are therefore generally happy to provide clarification.

Once you do get to solving the problem, make sure to communicate your thinking at each step to the interviewer. Not only does this help them assess your thinking, which is the whole point of the exercise (even more so than getting the right answer!), but it can help them steer you back on the right track if there is any misunderstanding. If you operate with the wrong assumptions in your head for too long, you can waste a lot of time, so talk your interviewer through your thought process to increase your chances of success.

Be specific about the problem, not the tools
Your interviewers generally aren’t concerned if you remember the exact Java API to split a string, so don’t be afraid to ask, or to default to pseudo-code if you can’t remember.

Similarly, if you need to perform a trivial operation, like converting from miles to kilometers, just calling a helper function without implementing it is probably fine—you can always implement those smaller details once the broader solution is fully fleshed out.

After the interview

Once you’ve finished your onsite, there’s a tricky balance between letting go of mistakes you made while also learning to improve. On the one hand, don’t berate yourself over what you didn’t know. If there’s a critical gap in what you know and what the job requires, then maybe it wasn’t the right role in the first place. And if it’s silly mistakes you’re concerned about, remember that interviewers are human—and they know you are too.

At the same time, however, use each interview as a learning experience. If there’s a problem that stumped you, work it out on your own time after the interview, figure out what about it was difficult, and file those conclusions away for use in the future. In addition, once a hiring decision has been made, it’s fair to ask for feedback on your technical evaluation, which can help you better understand where you went wrong—and where you shined.

Lastly, take a few minutes to send personalized follow-up thank you emails to your interviewers. It can feel like a bit of a formality, but will never hurt your chances—though thank yous generally won’t make or break the decision of whether to move forward with extending an offer. Don’t expect your interviewer to respond (though they might!), but rest assured knowing you’ve checked that box in each interviewer’s mental list of the impression you’ve left.

The post Your Technical Onsite Interview Survival Guide appeared first on Career Advice.

Read Full Article
Visit website
  • Show original
  • .
  • Share
  • .
  • Favorite
  • .
  • Email
  • .
  • Add Tags 

Centered at the intersection of marketing, design, and engineering, the ever-evolving role of the product manager has emerged as a stand-alone business function within tech organizations. These “mini CEOs” are not only tasked with satisfying core business functions, but must also bring emotion and ingenuity to digital experiences built with nothing more than 0s and 1s.

The highest-paid technologists in the U.S., U.K., and Australia, product manager role differs across organizations. Some focus more on back-end or program management-style roles that may be completely internally facing. Consumer-facing organizations, on the other hand, may have several teams dedicated to solving user pain points and improving the overall experience for their target audience. Even within organizations, larger product teams often divide and conquer based on skillsets. Despite the core differences between the various PM roles, however, the underlying foundations of what makes a good product manager hold true across organizations of all types.

Let’s dive into which skills tech companies look for in product managers.

Technical skills

Before diving into the more nebulous skills necessary to successful product management, it goes without saying that PMs must be technical. A good PM needn’t necessarily be a software expert, but should have the technical acumen necessary to prioritize projects. A core understanding of product complexity from a code perspective ensures proper team collaboration, respect, and expectations. Maintaining a reliable code base is just as important as shipping new features to customers—and high-quality PMs can help to minimize engineering risks.

Companies like Google prefer software development as a prerequisite for product managers. While you can certainly find PM opportunities that don’t require an engineering background, a good technical understanding will never hurt, so learning some software basics is one way to boost your PM application.

User-centricity

Whether you’re working behind the scenes or on an outward-facing feature, the product manager’s job is to understand the problem that’s being solved—and the product’s users are your best source of information. Jeff Bezos instills this philosophy throughout Amazon, claiming that “we see our customers as invited guests to a party, and we are the hosts. It’s our job every day to make every important aspect of the customer experience a little bit better.” Product managers are the champions of this principle in any company, so it’s important prioritize empathy and understanding of who you’re serving.

Tech companies thus seek product managers who build with their target audience(s) in mind and constantly work to learn more about their customers. According the Hemal Shah, product lead at Twitter, “[product managers] know their target audience and the best ways to reach them.” Some companies may prefer product managers with previous industry knowledge, but many others tend to hire those from diverse backgrounds with new and creative ways of thinking through problems.

Data-driven, quick decision making

Product managers are the decision-makers when it comes to user experience—and given the time-sensitivity often associated with user issues, PMs must be able to make the right decisions in short periods of time.

As more companies embrace “lean” principles, releasing products or features early for the purpose of testing them in the market, rapid decision-making becomes increasingly more important. Product managers are not only responsible for flagging user issues, but also for putting out fires while remaining calm—all the while managing the multiple stakeholders involved in any product launch.

But it’s not enough to make a fast decision. Companies want PMs who make the right decisions, and therefore look to fill PM roles with people who have a sharp mind for data, and who can translate that data into actionable recommendations.

An eye for design

Many companies look for technical PMs, but good design sense is an increasingly crucial skill as companies realize the importance of design to a great user experience.

The importance of good design is evidenced by Airbnb, which, some may say, still exists today because of a keen focus on design and aesthetic from day one. In a moment of unscalable, non-data-driven genius, the entire early team flew to New York to take high-resolution photographs of property listings—an ultimate turning point for the company.

Knowing what good design looks like doesn’t require product managers to become Sketch wizards, but rather to point out good UI and UX, and to make suggestions when something doesn’t look or feel right. As with many PM functions, incorporating design sense requires a bit of art and science—attention to what the data is saying, but also an eye to what makes sense from a design perspective.

An experimentation mindset

In an era of shorter development cycles, better access to data, and “fail fast” company cultures, product managers are expected to approach challenges as experiments, with the outcome of each experiment leading to better user experiences.

At the same time, however, experimentation can be costly—in terms of dollars, time, and resources—so the best product managers know how to prioritize experiments that could lead to tangible positive outcomes. In growth-focused PM roles, for example, the product owner is often tied to conversion metrics that are reported back to management and investors, so he or she must balance outcomes and user experience with the costs of each experiment—as well as the potential upside should an experiment be successful.

People skills

People management is at the heart of every PM role. From ensuring that designers and engineers are working on the highest-priority tasks to keeping secondary stakeholders such as legal, quality, operations, and data teams well aware of product changes, product managers must be on top of all team functions.

A PM must therefore be dependable and able to delegate, but at the same time willing to roll up his or her sleeves in a crunch. This is where not only a wide variety of skills comes in handy, but also the ability to work effectively with hugely different personalities and across all levels in an organization. Unlike roles that involve working squarely within teams, product managers need the emotional intelligence necessary to interfacing with colleagues of all types. These softer skills allow good PMs to read and quickly respond to situations in ways that resonate with the affected individual(s), reducing the friction that would otherwise occur between business units or teams.

Organizational swiss army knives

Given product managers sit between a number of crucial business functions, it’s no surprise that the skills a successful PM needs are highly diverse. From technical savvy to user empathy, each day in the life of a PM is guaranteed to be wildly different, but those who can master a balance of the above six skills will be crucial to any organization they work with.

The post 6 Skills Tech Companies Look for in Product Managers appeared first on Career Advice.

Read Full Article
Visit website
  • Show original
  • .
  • Share
  • .
  • Favorite
  • .
  • Email
  • .
  • Add Tags 

While engineering is sometimes thought of as a solitary craft, building modern technology products requires cohesive and collaborative teams of people. And, like teams of all types, strong leaders are needed to communicate, delegate, and motivate.

But these skills don’t always come naturally to technical people. Whether you’re new to leading a team or looking to up level your skills, here are four characteristics that every successful engineering manager has mastered.

Technical Ability

In general, studies show that managers are more effective when they are knowledgeable about the subject matter their team is dealing with. And engineering management is no exception. The very best engineering managers tend to be highly skilled engineers in their own right.

On the one hand, a technically competent manager will have a superior handle on the work that they are managing and therefore be better able to make recommendations and to evaluate necessary trade-offs.

Another (perhaps maybe less obvious) reason is that technically talented managers are often better able to garner respect from their teams. Pure managers—even those with exceptionally strong management ability—can struggle to manage high performing individual contributors, who tend to have a tough time taking orders from managers that don’t fully understand their craft.

Steve Jobs went through these growing pains in the early stages of Apple, hiring “professional managers” and subsequently realizing that his talented employees couldn’t learn from “bozos” who didn’t have any skills beyond people management. While engineering managers certainly need soft skills to be successful, a strong technical foundation can be a huge advantage.

Communication

While it may seem like a platitude, arguably the most important skill for any leader is the ability to set a direction and communicate it effectively to his or her team. This doesn’t always mean verbal or even written direction—the best leaders back up their words with behavior that sets the standard for everyone around them.

Further, successful engineering managers know how to communicate upward to superiors and laterally to other departments, keeping the organization at large in sync and making sure that their team is contributing meaningfully to the broader company. According to Chris Fischer, CTO and VP of Product at Aaptiv, one significant challenge of being an engineering leader is the need to communicate effectively with many types of people. You must “be able to perform capably [in all] types of conversations—often within the same hour… you must appreciate different roles, different needs, and different styles.”

Emotional Intelligence

While the process of engineering can often seem cold and scientific, the reality of an engineering organization is just as human as any other. A manager that can’t relate to his or her team on an emotional level will struggle to build the camaraderie and trust necessary to cooperate and do good work.

According to answers on one popular Hacker News post about how to be a good technical lead, engineering managers must be sure to make themselves available for questions, even if they’d rather not be interrupted. This can run counter to high efficiency, but it’s important that managers spend the time to develop their team members, ensuring better performance in the future and ultimately improving efficiency.

Fischer suggests that you “pay attention to and prepare the style of communication that suits the other person most effectively.” This doesn’t have to be complicated, he says: If you’re unsure of which communication style someone prefers, simply “ask them how, where, and when they prefer to be spoken to.”

Knowing when, and when not, to get involved

According to Hired’s SVP of Engineering, Nidhi Gupta, the hardest part about the transition to engineering manager is learning to “bite your tongue” rather than giving your frank opinion straight off the bat. Engineering managers must calibrate when a team or team member requires their input—and, just as importantly, when they’re better off left alone.

Nothing frustrates a high performer more than having someone unnecessarily supervise a task that they are fully capable of performing independently. Further, promoting a culture of accountability is crucial in a complex environment like engineering, where no manager can ever have full visibility into what his or her team is doing. Micromanagement, however, can work in opposition to the goal of accountability.

Conversely, inexperienced employees or teams not only crave direction and guidance—they often need it to build confidence and expertise. In critical situations, an extra set of eyes can be crucial, and the presence of a steady hand comforting for a team under pressure.

The same Hacker News post touches on the importance of allowing your team members to explore approaches they think are correct—even if you believe they’re wrong. This is a tricky balance, because it means allowing a team member to potentially waste time on a project, but will both facilitate them becoming a better engineer and build trust that you’re there not to micromanage, but to develop their skills.

Great engineering managers have mastered the skill of assessing the situation, both in terms of its importance and in terms of the competence of those involved, including knowing whether to let the team run its own show or to step in.

The Balancing Act

Engineering managers are a special breed, requiring both technical savvy and people skills. And this combination doesn’t come easy—according to one Senior Engineering Manager at Facebook, “the first few months are going to be miserable,” but those willing to discard some skills in exchange for others can be successful.

Whether you’re new to leading a team or have been honing these skills for years, it’s easy to see that being a engineering manager is a constant balancing act between these two sides of the coin—but that successful leaders not only create high-performing teams

The post 4 Skills Every Successful Engineering Manager Has Mastered appeared first on Career Advice.

Read Full Article
Visit website

Read for later

Articles marked as Favorite are saved for later viewing.
close
  • Show original
  • .
  • Share
  • .
  • Favorite
  • .
  • Email
  • .
  • Add Tags 

Separate tags by commas
To access this feature, please upgrade your account.
Start your free year
Free Preview