Talent matching in emerging markets.

  • We cherry-pick the parts of Bootstrap that we want to use using SCSS. We mainly use the typographical and layout-related parts of Bootstrap.

  • jQuery's pretty useful for DOM manipulations within Angular directives. We're considering switching to a lighter-weight alternative though, such as Zepto.

  • CloudFront's easy to use in front of S3, especially for videos, which don't load reliably from S3. We've noticed latency issues with CloudFront, and so don't use it for everything, though.

  • We mainly use Google Analytics and our own internal analytics tools for our analytics.

  • All of our frontend code is on AngularJS. Directives, controllers, and services really help in organizing code in order to keep things maintainable, and two-way binding makes data input easy. The large ecosystem of modules for directives is fantastic, too.

  • We use ElasticSearch to index and query items that need to be searched full-text (such as jobs and candidates). We mirror changes to our main datastore (PostgreSQL) onto ElasticSearch using SQLAlchemy's events, denormalizing as needed.

  • All of our pull requests are automatically tested using Jenkins' integration with GitHub, and we provision and deploy our servers using Jenkins' interface. This is integrated with HipChat, immediately notifying us if anything goes wrong with a deployment.

  • Each piece of our infrastructure is monitored using Nagios, alerting us immediately if anything goes wrong (hopefully before anyone else notices), and with a level of granularity that really helps in resolving things quickly when things are on fire.

  • We use nginx to serve all of our static files, and to load balance our multiple backends. Our nginx frontend servers are themselves load-balanced using a Linode NodeBalancer.

  • We make sure that our site is indexable by bots and spiders (such as GoogleBot and Facebook's fetcher) using Prerender, which runs our JS and render and serves the final page to bots that typically don't have JS capabilities.

  • We use Redis as a key-value store, a cache, and a message queue. It's a ridiculously fast and simple-to-maintain jack-of-all-trades.

  • PostgreSQL is our main datastore, and we make judicious use of its fantastic features: JSON columns, recursive CTEs, streaming binary replication, triggers, and constraints, among others.

  • PostGIS makes it easy (and fast) to do geographic queries, such as nearest-neighbor and bounding box queries.

  • Most of our backend code is in Python. We use TypeScript for frontend code, and we use Ruby for our build system (Guard).

  • We use Jade when writing HTML, which is much easier to read and maintain. We compile it to HTML before deploying it though, and don't use Jade's client-side rendering features.

  • All of our CSS is written in SCSS, Sass's CSS-like syntax. Variables, functions, mixins, and nesting are simply heaven compared to plain CSS.

  • All of our background jobs (e.g., image resizing, file uploading, email and SMS sending) are done through Celery (using Redis as its broker). Celery's scheduling and retrying features are especially useful for error-prone tasks, such as email and SMS sending.

  • We use Tornado as our websockets server, using SockJS (an alternative to socket.io).

  • We use Google's geocoding and place services to figure out the geographical location of jobs and candidates, to best match them.

  • We make all of our changes through GitHub pull requests, which are each reviewed by at least one other developer.

  • All of our local development setups use VirtualBox (through Vagrant) to ensure consistent and identical development setups, freeing us from worrying about configuration inconsistencies.

  • All of our local development setups use VirtualBox (through Vagrant) to ensure consistent and identical development setups, freeing us from worrying about configuration inconsistencies.

  • All of our tasks are dealt with on Trello, from inception to development and deployment. It's really helpful for everyone to be able to see what people are doing, and to be able to observe the progress on cards that people are interested in.

  • We monitor and troubleshoot our app's performance using New Relic, which gives us a great view into each type of request that hits our servers. It also gives us a nice weekly summary of error rates and response times so that we know how well we've done in the past week.

  • Source control. 'nuff said.

  • HipChat is fantastic for its chat and its integration with GitHub (among others). We also have our own Hubot instance named kbot, which we use all the time.

  • All of our servers are hosted on Linode, which scored better in our benchmarks, and are significantly cheaper than EC2 instances.

  • We use Stripe to process our credit card payments.

  • We use Apache Spark in computing our recommendations.

  • All of our external emails are sent using SendGrid. SendGrid's statistics dashboards help us figure out whether our emails are reaching people, and how much attention is paid to them.

  • All of our support is done using Intercom's interface. External support emails are handled using Intercom's email integration, allowing us to manage all support tickets from Intercom.

  • Amazon Route 53 is a convenient way to manage our DNS routes. We just use the web UI for now, since we don't have any complex DNS setups.

  • All of our servers are provisioned by Ansible, with no manual provisioning involved. This lets us easily roll out new servers, with no chance for human error when configuring the servers. We use the same code to provision local development environments on Vagrant, which eliminates configuration discrepancies between development and production.

  • We load balance our ElasticSearch cluster using HAProxy. The health checks come in handy.

  • Server and application metrics are all stored in InfluxDB for capacity planning and anomaly detection.

  • Our internal emails (such as exception notifications) are sent via Amazon SES, since it's cheaper than using Sendgrid. We also use Amazon SES as a fallback in case we have deliverability issues with Sendgrid.

  • We fall back to Nexmo when Chikka (https://api.chikka.com) and Semaphore (http://semaphore.co) have downtime or deliverability problems. Chikka and Semaphore are local (Philippine) SMS APIs handled by SMART and Globe, respectively, and report higher deliverability rates than Nexmo (at lower cost).

  • All file uploads go straight to Amazon S3 (with maybe some preprocessing). Amazon S3's cheap and easy-to-use, with no need to worry about disk space limits.

  • We have our own special Hubot instance named kbot, that does everything from reminding us what to do, showing cat and corgi images, and notifying us of system errors.

Verified by

Stack Match