Forem: Ivan Neto

Eastern European Developers: Which Country to Choose for Your Project

Ivan Neto — Thu, 27 Feb 2020 21:59:55 +0000

Over the last decades, Eastern Europe has managed to become one of the top offshore destinations in the world. It all started with tech giants such as Microsoft, IBM, Apple, and Google, who opened their branches in Eastern European countries. Their example inspired the other tech companies, who saw the benefits of outsourcing to Central and Eastern Europe (CEE).

According to Clutch, there are almost 2,000 offshore software development companies in this region as of January 2020. Almost 700 firms thereof are based in Ukraine, more than 600 – in Poland, and 274 – in Romania. In this article, we are going to give an overview of these top 3 locations and compare them according to various criteria. We will also find out why clients from the US and Western European countries prefer Eastern Europe as the number one offshore destination.

Top Destinations for Software Development in Eastern Europe

As we've already mentioned, the most popular Eastern European countries to outsource software development are Ukraine, Poland, and Romania. Now we'll give an overview of the IT industry in each of them.

Poland

Poland is an EU country with a rapidly growing economy. IT services in Poland generate over 29% jobs in the Polish labor market, as per the "Business Services Sector in Poland 2019" report by ABSL. This fact makes Poland one of the most favorable offshore destinations in Eastern Europe, together with other facts and statistics, such as:

The Polish IT industry grows by 5-10% a year.
According to Top Coder ranking, Poland now occupies the 5th place in the world as per software development skills.
In 2018, the number of IT professionals employed at outsourcing companies was about 45,000 as related to the total talent pool size of over 250,000.
In 2019, the IT market revenue in Poland amounted to $11.79 billion. According to predictions, the revenue will grow up to $12.1 billion in 2020 and $12.1 billion in 2021.
By 2022, sales of IT services in the country are expected to reach $15 billion.

Romania

Being also a member of the EU, Romania features one of the fastest growing IT markets in Central and Eastern Europe. The country is sixth in the world according to the number of certified IT specialists, specifically, about 100,000. Here are some more facts about this offshore destination:

In 2003, Microsoft acquired Romanian antivirus technology by GeCAD Software.
The IT market in Romania grows at about 40–60% a year.
The most rapidly growing segment of the IT market is offshore software development, with up to $4.2 billion in total revenues.
HackerRank challenges showed that Romania is the 20th country in the world having the best developers.
185,00 professionals are employed in the IT industry.

Ukraine

Here are some of the recent statistics about the state of the IT industry in Ukraine.

Currently, about 4,000 IT companies operate on the market.
As of 2019, there were about 160,000 IT professionals in Ukraine, over 60% of which work for outsourcing companies, mainly from the United States. It is predicted that in 2020, the number of software developers in Ukraine will increase by 20,000.
Ukrainian IT industry grows by about 26% a year.
As per forecasts by experts, revenues in the Ukrainian IT industry amounted to $5 billion in 2019.
Ukraine is 20th in the T. Kearney's 2019 Global Services Location Index (GSLI). The country has moved up 4 positions as compared with 2017.

Additionally:

The average score across all HackerRank challenges as of 2018 showed that Ukraine is the world's 11th country having the best developers. According to this data, Ukrainian developers had an average score of 88.7% across all challenges.
In 2017, Ukraine was awarded the "Outsourcing Destination of the Year" by the Global Sourcing Association.
Grammarly, Preply, and Petcube come from Ukraine.

Software Developers in Eastern Europe: Comparison

Now let's compare the software development potential in the top 3 CEE countries by using criteria such as English skills, tech ranks, hourly rates, size of the talent pool, industry focus, and core technologies.

English skills. In general, IT professionals in all three countries are fluent in English. According to a survey by Daxx, 80% of Ukrainian developers speak English. 33% of them have the upper-intermediate level whereas 35% have the intermediate level. As per EF English Proficiency Index, Poland is #11 of 100 countries/regions and #9 in Europe in terms of English proficiency, being ranked as "very high proficiency". The same index shows that Romania occupies the 16th and 14th places, accordingly, being ranked as "high proficiency."
Tech ranks. Among the three countries, Poland has the best tech rank both on HackerRank (3rd place) and TopCoder (5th place).
Hourly rates. According to PayScale, average hourly rates for the three countries are roughly the same - $16 per hour. It is greater than in India or the Philippines, but still much lower than in the US or Western Europe.
Size of the talent pool. Poland remains the leader in terms of the talent pool size of over 250,000, which amounts to ne fourth of the total population of programmers in the CEE.
Industry focus. Each country has its own IT industry focus, which makes it easier for clients to choose the preferred destination. Ukrainian IT companies specialize in startups, custom software development, and eCommerce. Polish developers tend to focus on enterprise projects whereas Romanian ones – on fintech projects.
Core technologies. The annual survey of Ukrainian software engineers by DOU, a local online community for IT professionals, shows that Java is the most popular programming language in Ukraine, followed by JavaScript, C#, PHP, and Python. A similar rating by Bulldogjob in Poland shows that the top 5 most popular technologies are JavaScript, Java, C++, SQL, and C#. As for Romania, the leaders are PHP, ASP.NET, Python, Java, and Perl. As we can see, Java is popular in all three countries whereas PHP is popular in Ukraine and Romania. Apart from this, the set of core languages and technologies is quite diverse.

Why Outsource Software Development to Eastern Europe?

The final section of our article is dedicated to the advantages of offshore software development in Eastern Europe, which are also the reasons why clients choose this destination.

Technology Stack

Technical education has been important in Eastern Europe ever since the times of the Soviet Union. However, during those times, the universities focused mostly on hardware than on software. Today, the focus has been shifted from hardware to software in response to modern market requirements, thus gradually turning Eastern Europe into one of the world's most popular offshore software development hubs. Tens of thousands of certified IT specialists graduate from Eastern European universities every year, expanding the vast talent pool of this outsourcing destination.

Foreign Language Proficiency

Fluent English is one of the key requirements for work in the outsourcing IT industry. It is the preferred language for communication between international teams and successful cooperation with clients. Many Eastern European IT companies offer free English courses for co-workers on their premises, thus contributing to the improvement of this important skill. Additionally, Polish developers speak fluent German and Romanian developers – fluent French. Clients from the United States and Western Europe enjoy working with teams from these countries because there's no language barrier.

Self-Education

With the lightning-fast development of modern technology, self-education is crucial for IT professionals so they can always stay up to date with the latest trends. With this purpose, Eastern European developers constantly attend various conferences, both internal and external, and listen to online courses and webinars. All expenses are typically covered by employers. And these efforts are worth it -developers from Poland, Ukraine, and Romania rank highly on both HackerRank and TopCoder.

Pricing

Eastern European developers offer quite affordable rates as compared to their Western peers. The highest rates are in Poland — $50-$99/hour, but it is still lower than in Western Europe. The lowest prices are in Moldova — $20-$24/hour.

Cultural Value Set

Despite once belonging to the former Soviet Union, the culture of software developers in the CEE countries can be defined as western and progressive. Most developers are young people with an open mindset. Ukrainian and Polish developers have decades of experience working with global technology companies in Europe and other countries. At the same time, Romanians can sometimes lack an innovative approach because they may be reluctant to take risks.

Size of Talent Pool

The main reason why tech companies from the United States and Western Europe choose outsourcing is the lack of talent pool in their area. High-speed Internet and modern technologies allow employing people from all over the world even on a remote basis. The abundance of highly skilled, open minded, English speaking professionals at fair prices makes Eastern Europe an IT outsourcing paradise.

The total number of IT professionals in the region is 700,000 people employed at 2,000 companies, and this number is growing because of 60,000 IT graduates appearing every year. Each country focuses on specific technologies, offering potential clients a diverse set of various technologies to choose from. For example, Romanian developers are well versed in fintech, Poland focuses on enterprise solutions, and Ukrainian developers work with the most cutting-edge technologies, such as artificial intelligence or blockchain.

Which Country Is the Best for You?

Every client has their own project requirements, but each CEE country has its own specifics. Therefore, the best recommendation here is to choose a country based on those requirements. You may find Poland or Romania more reliable because of EU membership, but these countries may lack specialists in the technology stack that you need for your project. So, here are our recommendations on making the right choices:

Know your budget. Average hourly rates in CEE countries can be roughly the same, but they can vary for senior-level developers. Therefore, we recommend that you look up the rates of software engineers per country and choose the one that is best for your budget.
Have a clear understanding of the tech stack needed for your project. Each Eastern European country has its own strengths regarding the tech skills of local software engineers. For example, HackerRank reports that Polish engineers are the first in Java whereas Ukrainian developers are the first in security.
Choose according to the type of your company. If you're a startup, you can reach out to Ukrainian developers. If you're a large enterprise, Poland would be your choice, and so on.

And remember: it doesn't matter which country you choose for outsourcing software development. Companies in those countries can also be different, so we advise that you thoroughly pre-screen the company of your choice, preferably with the help of local specialists.

Wrapping Up

Eastern Europe is an attractive outsourcing destination due to several reasons such as broad technology stack, English language proficiency, affordable rates, size of the talent pool, and cultural value set. The most popular outsourcing destinations in CEE are Ukraine, Poland, and Romania. It is possible to not only open an offshore development center in one of those countries but also build a remote team.

Find remote developers

YouTube API Integration: Uploading Videos with Django

Ivan Neto — Thu, 27 Sep 2018 16:02:30 +0000

A short while ago, I was working for a client, integrating video reviews in their website. Like any motivated developer solving a novel problem, the first thing I did was Google it, and I found a plethora of unhelpful or misguided answers on how to achieve something entirely different, or outdated and unmaintained Python packages. Eventually, I bit the bullet and the team and I built everything from scratch: we created the views, learned about Google’s API, created the API client, and eventually succeeded in programmatically uploading videos from Django.

In this post, I’ll try to guide you step by step in how to post YouTube videos from your Django app. This will require a bit of playing around with Google API credentials—first with the web interface, then with the code. The YouTube part itself is very straightforward. We need to understand how Google stuff works because sometimes it’s tricky and the information is spread through many places.

Prerequisites

I recommend familiarizing yourself with the following before we begin working:

An interesting bit of code to note is the following Python Snippet from the Google YouTube API Docs:


# Sample python code for videos.insert

def videos_insert(client, properties, media_file, **kwargs):
  resource = build_resource(properties) # See full sample for function
  kwargs = remove_empty_kwargs(**kwargs) # See full sample for function
  request = client.videos().insert(
    body=resource,
    media_body=MediaFileUpload(media_file, chunksize=-1,
                               resumable=True),
    **kwargs
  )

  # See full sample for function
  return resumable_upload(request, 'video', 'insert')

media_file = 'sample_video.flv'
  if not os.path.exists(media_file):
    exit('Please specify a valid file location.')
videos_insert(client, 
    {'snippet.categoryId': '22',
     'snippet.defaultLanguage': '',
     'snippet.description': 'Description of uploaded video.',
     'snippet.tags[]': '',
     'snippet.title': 'Test video upload',
     'status.embeddable': '',
     'status.license': '',
     'status.privacyStatus': 'private',
     'status.publicStatsViewable': ''},
    media_file,
    part='snippet,status')

Getting Started

After you’ve read the prerequisites, it’s time to get started. Let’s see what we need.

Toolbelt

Basically, let’s create a virtual environment. I personally prefer pyenv. Setting up both is out of the scope of this post, so I’m going to post some pyenv commands below and, if your preference is virtualenv, feel free to replace the commands accordingly.

I’m going to use Python 3.7 and Django 2.1 in this post.

➜  ~/projects $ mkdir django-youtube
➜  ~/projects $ cd django-youtube
➜  ~/projects/django-youtube $ pyenv virtualenv 3.7.0 djangoyt
➜  ~/projects/django-youtube $ vim .python-version

        djangoyt

Installing dependencies:

➜  ~/projects/django-youtube $ pip install google-api-python-client google-auth\
 google-auth-oauthlib google-auth-httplib2 oauth2client Django unipath jsonpickle

Now time to start our django project:

➜  ~/projects/django-youtube $ django-admin startproject django_youtube .

Pause for some Google Config.

Let’s config our project credentials now so we are able to use the Google APIs.

Step 1. Go to the following URL: https://console.developers.google.com/apis/library/youtube.googleapis.com

Step 2. Create a New Project.

Step3. Click "Enable APIs and Services."

Step4. Look for Youtube Data API v3, click "Enable."

Step 5. You should get a message about credentials.

Step 6. Click on the "Create credentials" blue button on the right side, and you should get the following screen:

Step 7. Choose Web server, User Data

Step 8. Add authorized JS origins and redirect URIs. Continue to the end.

OK we are done with our credentials set up. You can either download the credentials in a JSON format or copy the Client ID and Client Secret.

Back to Django

Let’s start our very first Django app. I usually name it “core”:

(djangoyt) ➜  ~/projects/django-youtube $ python manage.py startapp core

Now, let’s add the following to our root urls.py file to route the homepage requests to our core app:

# urls.py

from django.urls import path, include


    path('', include(('core.urls', 'core'), namespace='core')),

In the core app, let’s have another urls.py file, with some config also:

# core/urls.py

from django.conf import settings
from django.conf.urls.static import static
from django.urls import path

from .views import HomePageView

urlpatterns = [
    path('', HomePageView.as_view(), name='home')
]

if settings.DEBUG:
    urlpatterns += static(
        settings.STATIC_URL, document_root=settings.STATIC_ROOT)
    urlpatterns += static(
        settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

See there is an empty path pointing to HomePageView. Time to add some code.

Let’s do now a simple TemplateView just to see it running.

# core/views.py
from django.shortcuts import render
from django.views.generic import TemplateView


class HomePageView(TemplateView):
    template_name = 'core/home.html'

And of course we need a basic template:

# core/templates/core/home.html
<!DOCTYPE html>
<html>
<body>

<h1>My First Heading</h1>
<p>My first paragraph.</p>

</body>
</html>

We need to do some settings tweaks:

# settings.py


from unipath import Path

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = Path(__file__).parent


INSTALLED_APPS = [
    # [...]
    'core',
]


STATIC_ROOT = BASE_DIR.parent.child('staticfiles')

STATIC_URL = '/static/'


MEDIA_ROOT = BASE_DIR.parent.child('uploads')

MEDIA_URL = '/media/'

Let's create now a YoutubeForm and add as form_class to the view:

from django import forms
from django.views.generic.edit import FormView


class YouTubeForm(forms.Form):
    pass


class HomePageView(FormView):
    template_name = 'core/home.html'
    form_class = YouTubeForm

Try to run your application now, and the page will look like this:

Pause to do Authorization

First of all, you have to create a model to store your credentials. You could to through a file, cache system, or any other storage solution, but a database seems reasonable and scalable, and also you can store credentials per users if you want.

Before proceeding, an adjustment needs to be made—there is fork of oauth2client that supports Django 2.1 that we have to use. Soon, we’ll have official support, but in the meantime, you can inspect the fork changes. They are very simple.

pip install -e git://github.com/Schweigi/oauth2client.git@v4.1.3#egg=oauth2client
# Because of compatibility with Django 2.0

Go to your settings.py and place the Client ID and Client Secret you got from Google in previous steps.

# settings.py

GOOGLE_OAUTH2_CLIENT_ID = '<your client id>'
GOOGLE_OAUTH2_CLIENT_SECRET = '<your client secret>'

Caution: storing secrets in your code is not recommended. I’m doing this simply as a demonstration. I recommend using environment variables in your production app, and not hardcoding secrets in application files. Alternatively, if you downloaded the JSON from Google, you can also specify its path instead of the settings above:

GOOGLE_OAUTH2_CLIENT_SECRETS_JSON = '/path/to/client_id.json'

The oauth2client package already provides plenty of functionality, with a CredentialsField already done that we can use. It’s possible to add more fields, like a foreign key and created/modified dates so we get more robust, but let’s stay simple.

Simple model to store credentials:

# core/models.py
from django.db import models
from oauth2client.contrib.django_util.models import CredentialsField


class CredentialsModel(models.Model):
    credential = CredentialsField()

Time to create migrations and migrate:

(djangoyt) ➜  ~/projects/django-youtube $ ./manage.py makemigrations core
(djangoyt) ➜  ~/projects/django-youtube $ ./manage.py migrate

Now let’s change our API views to be able to authorize our application:

In our core/urls.py file, let’s add another entry for the first authorization view:

# core/urls.py
from .views import AuthorizeView, HomePageView


urlpatterns = [
    # [...]
    path('authorize/', AuthorizeView.as_view(), name='authorize'),
]

So first part of the AuthorizeView will be:

# core/views.py

from django.conf import settings
from django.shortcuts import render, redirect
from django.views.generic.base import View

from oauth2client.client import flow_from_clientsecrets, OAuth2WebServerFlow
from oauth2client.contrib import xsrfutil
from oauth2client.contrib.django_util.storage import DjangoORMStorage
from .models import CredentialsModel

# [...]

class AuthorizeView(View):

    def get(self, request, *args, **kwargs):
        storage = DjangoORMStorage(
            CredentialsModel, 'id', request.user.id, 'credential')
        credential = storage.get()
        flow = OAuth2WebServerFlow(
            client_id=settings.GOOGLE_OAUTH2_CLIENT_ID,
            client_secret=settings.GOOGLE_OAUTH2_CLIENT_SECRET,
            scope='https://www.googleapis.com/auth/youtube',
            redirect_uri='http://localhost:8888/oauth2callback/')

        # or if you downloaded the client_secrets file
        '''flow = flow_from_clientsecrets(
            settings.GOOGLE_OAUTH2_CLIENT_SECRETS_JSON,
            scope='https://www.googleapis.com/auth/youtube',
            redirect_uri='http://localhost:8888/oauth2callback/')'''

And then second part:

        if credential is None or credential.invalid == True:
            flow.params['state'] = xsrfutil.generate_token(
                settings.SECRET_KEY, request.user)
            authorize_url = flow.step1_get_authorize_url()
            return redirect(authorize_url)
        return redirect('/')

So if there is no credential or the credential is invalid, generate one and then redirect it to the authorize URL. Otherwise, just go to the homepage so we can upload a video!

Let’s access the view now and see what happens:

Let’s create a user then, before going to that page.

(djangoyt) ➜  ~/projects/django-youtube $ python manage.py createsuperuser

Username (leave blank to use 'ivan'): ivan
Email address: ivan***@mail.com
Password:
Password (again):
This password is too short. It must contain at least 8 characters.
Bypass password validation and create user anyway? [y/N]: y
Superuser created successfully.

Let’s also log in with it via /admin. After, let’s access our /authorize/ view again.

Then,

OK, it tried to redirect to the callback URL we configured long ago with Google. Now we need to implement the callback view.

Let’s add one more entry to our core/urls.py:

# core/urls.py

from .views import AuthorizeView, HomePageView, Oauth2CallbackView

urlpatterns = [
    # [...]
    path('oauth2callback/', Oauth2CallbackView.as_view(),
         name='oauth2callback')
]

And another view:

# core/views.py


# the following variable stays as global for now
flow = OAuth2WebServerFlow(
    client_id=settings.GOOGLE_OAUTH2_CLIENT_ID,
    client_secret=settings.GOOGLE_OAUTH2_CLIENT_SECRET,
    scope='https://www.googleapis.com/auth/youtube',
    redirect_uri='http://localhost:8888/oauth2callback/')
# or if you downloaded the client_secrets file
'''flow = flow_from_clientsecrets(
    settings.GOOGLE_OAUTH2_CLIENT_SECRETS_JSON,
    scope='https://www.googleapis.com/auth/youtube',
    redirect_uri='http://localhost:8888/oauth2callback/')'''


# [...]


class Oauth2CallbackView(View):

    def get(self, request, *args, **kwargs):
        if not xsrfutil.validate_token(
            settings.SECRET_KEY, request.GET.get('state').encode(),
            request.user):
                return HttpResponseBadRequest()
        credential = flow.step2_exchange(request.GET)
        storage = DjangoORMStorage(
            CredentialsModel, 'id', request.user.id, 'credential')
        storage.put(credential)
        return redirect('/')

Note: The flow was moved to outside of the AuthorizeView, becoming global. Ideally, you should create it under the AuthorizeView and save in a cache, then retrieve it in the callback. But that is out of the scope of this post.

The get method of AuthorizeView is now:

    def get(self, request, *args, **kwargs):
        storage = DjangoORMStorage(
            CredentialsModel, 'id', request.user.id, 'credential')
        credential = storage.get()

        if credential is None or credential.invalid == True:
            flow.params['state'] = xsrfutil.generate_token(
                settings.SECRET_KEY, request.user)
            authorize_url = flow.step1_get_authorize_url()
            return redirect(authorize_url)
        return redirect('/')

You can take a look at similar implementations here. The oauth2clien package itself provides views but I particularly prefer to implement my custom Oauth view.

Now if you try the /authorize/ URL again, the OAuth flow should work. Time to see if this work is worth it and upload our video! The HomePageView will first check for credentials and if it’s all good, we are ready for uploading our video.

Let’s check how our new code for the HomePageView will look:

import tempfile
from django.http import HttpResponse, HttpResponseBadRequest
from googleapiclient.discovery import build
from googleapiclient.http import MediaFileUpload


class HomePageView(FormView):
    template_name = 'core/home.html'
    form_class = YouTubeForm

    def form_valid(self, form):
        fname = form.cleaned_data['video'].temporary_file_path()

        storage = DjangoORMStorage(
            CredentialsModel, 'id', self.request.user.id, 'credential')
        credentials = storage.get()

        client = build('youtube', 'v3', credentials=credentials)

        body = {
            'snippet': {
                'title': 'My Django Youtube Video',
                'description': 'My Django Youtube Video Description',
                'tags': 'django,howto,video,api',
                'categoryId': '27'
            },
            'status': {
                'privacyStatus': 'unlisted'
            }
        }

        with tempfile.NamedTemporaryFile('wb', suffix='yt-django') as tmpfile:
            with open(fname, 'rb') as fileobj:
                tmpfile.write(fileobj.read())
                insert_request = client.videos().insert(
                    part=','.join(body.keys()),
                    body=body,
                    media_body=MediaFileUpload(
                        tmpfile.name, chunksize=-1, resumable=True)
                )
                insert_request.execute()

        return HttpResponse('It worked!')

And the template:

# core/templates/core/home.html

        <!DOCTYPE html>
        <html>
        <body>

        <h1>Upload your video</h1>
        <p>Here is the form:</p>
        <form action="." method="post" enctype="multipart/form-data">
        { csrf_token }
        \{\{ form.as_p \}\}
        <input type="submit" value="Submit">
        </form>

        </body>
        </html>

Don't forget to add the video field to YouTubeForm:

class YouTubeForm(forms.Form):
    video = forms.FileField()

Here we go!

Voila!

Closing Notes

The code needs some improvement, but it’s a good starting point. I hope it helped with most of the Google’s YouTube API Integration problems. Here are a few more important things to note:

For authorization, it’s important to require login and extra permissions for the user that will authorize your application to be uploading videos.
The flow variable needs to be moved out from being global. It isn’t safe in a production environment. It’s better to cache based on the user ID or session who accessed the first view, for instance.
Google only provides a refresh token when you do the first authorization. So after some time, mostly one hour, your token will expire and if you didn’t interact with their API you will start receiving invalid_grant responses. Reauthorizing the same user who already authorized a client will not guarantee your refresh token. * You have to revoke the application in your Google Accounts page and then do the authorization process again. In some cases, you might need to run a task to keep refreshing the token.
We need to require login in our view since we are using a user credential directly related to the request.
There is a work in progress based on this experience and this post. Of course there is a lot to be added, but it’s a good starting point: https://github.com/ivancrneto/youtube-django

Uploading takes a lot of time, and doing it in your main application process can cause the entire application to block while the upload happens. The right way would be to move it into its own process and handle uploads asynchronously.

The code needs some improvement, but it's a good starting point. I hope it helped with most of the Google's API handling and of course uploading your video to YouTube!

Cheers!

What I have learned from eight years of being a remote developer

Ivan Neto — Sun, 10 Jun 2018 19:04:51 +0000

I enjoy working remotely. There are many advantages such as not having to commute to an office; having more time with my family and myself; being in a reserved workspace which helps with concentration and boosts productivity; being able to travel more often, having flexible work hours and the list grows.

For people who don't work remotely or have a home office (https://www.quora.com/What-is-the-difference-between-remote-work-telecommuting-and-a-home-office), it sounds like we are privileged. Most of my friends' jobs are not suitable to be remote one day and many consider remote jobs as dream jobs.

It's often difficult to see the hitches related to remote work. What I want with this post is not to give tips on how to handle to work properly, how to find remote work or how to purchase the proper equipment for that, but to show through my experience one face of it that is not easily perceptible. Only after some time you are capable to note details that make remote work amazing and are surprised by others that are extremely hard to anticipate when starting.

Let's see...

No perfection

“Do you work remotely? Do you work at home? Oh, that must be perfect!”

No, it's not perfect. Everything has advantages and disadvantages.

“Working remotely is bad, you don't have anyone to talk, you are mostly alone.”

Every choice you make has the good and the bad side. During the working hours, you are probably isolated (and this is not 100% true), but it's a matter of choice to not be when not working.

No dogs

This is a joke, of course. What I mean is, make sure you are in a peaceful environment, mainly if you have to do many video calls. Ensure there are zero chances of a neighbor dog barking in your background while you have to talk. I had this experience and someone complained, it's frustrating.

Really, no dogs

If you need to move, do. Maybe a soundproofing office? I'm not kidding. When you are working remotely, you have to take it seriously. Once I had to talk in a meeting and I couldn't. I missed a golden opportunity. Having to keep muting yourself because of some random unexpected noise hurts and might determine your next career step.

This means you need to choose carefully the place you live, the people around you, to guarantee you are able to work when you need to be in a silent place.

Split the office if possible

If you live in a house, it's not a bad idea to consider a small garden between it and the room you use for the office. That induces a psychological state of “leaving home” and “entering the office” and the opposite. For me, it works to perfection.

One of the big problems remote workers have is not setting boundaries between work and home and mixing everything.

I'd say the same for the office format. I don't like making my bedroom as an office or my office as a bedroom. No beds. Just office furniture.

Family

Many think you are not working! You are at home, aren't you? They knock the door, make random requests, the phone rings, as does the bell, the postman arrives, and they request you to receive the package, they shout “food is ready” when you are in a meeting.

They need to learn, as well as you do. You need to have a conversation with them a couple of times to make them understand. Or they do, or you'll end up renting a room or going to a co-working space every day.

The most difficult thing is teaching them are not at home. You are only at home after you leave the office room. That's the hardest.

Internet

When you start working by yourself, you start simple, of course. Then after a couple of years, you see yourself charging three times more, leading teams, working on big projects.

How do you feel about saying something like “hey, I'm not working today because I have no internet connection?” A contract with two ISPs and also a mobile 4G/5G connection as a backup is mandatory for me.

Equipment

So I have a Nobreak. Because if I have no power, I can stay up for eight hours and still work. I checked to make sure my two ISPs used different links and even if there was a general power outage, my mobile provider would stay up (because it's a national one) then I could keep working.

Once, we had the experience of losing the first 30 min of an hourly meeting to set up a microphone. It's bad when you have to do the same for another one. Don't ever allow that to happen twice!

I have backup headphones. Once, I had the experience of not having an extra pair, my main ones broke and my sound naturally had a lot of echoes. It was very difficult for anyone to understand me. People complained, of course.

Another essential topic is your furniture. If you do videos, it's crucial to have good furniture, to show you are in an office or at least show some professionalism. Additionally, they add to your physical (ergonomic means fewer doctors and medicine in the future) and psychological (work/home split) states.

Computers

Two computers as well are also good to have. One to keep at home, one for traveling, or going to events, or to keep safe until the first one breaks.

Bed is not for working, pajamas neither

I don't like to work when in my bed. It activates me. I have problems trying to sleep later. There is a similar situation if I try to work when wearing pajamas. I'm still trying to get up and don't make progress fast enough. That's the same splitting problem. I need clothes to work and clothes to stay at home. They don't need to be better, just slightly different. Tell your brain when you are in your bed, it's not working time. And when you are using pajamas, it's still not working time.

Dropbox

A Dropbox (or similar) account. What if you go on vacation, don't bring your computer and there is a critical bug in production? Only Dropbox and any PC saves you. Or be terribly sad with your early trip back home to fix that bug.

Clients

Regarding clients, I have observed a curious behavior. As they don't see you, some think you are a robot 24/7 living inside the chat app. Of course (and I keep saying that, because it's important to emphasize), everything depends on your relation to them, and whether you work alone and deliver your stuff later or work with a team and need to be online for a couple of hours.

It's fundamental to work with good clients, be very selective as the time goes, and make sure they have experience with remote work. There are many situations:

It's a one-to-one relationship, where you work on a project for a single person;
A company with many remote contractors;
A company with everyone on-site and you are the only one remote;
You are an employee and works partially remotely and partially on-site;
You own a company and have many people and companies as clients.

No matter what situation you are, some clients want to reach out anytime. Many do not realize there is a real person outside of the chat platform and you should not allow them to ask you to do long demanding tasks when you are about to leave or at non-sense times like after 8, 9 pm or before 6 am. Of course, downtime and critical bugs happen. But we need to set boundaries and say “no, it's after 5 pm” (or 6 pm or whatever the time you stop), let's continue tomorrow. That's totally fine. Once agreed beforehand, mostly.

Still Clients

You miss the day-to-day of your client. So... you don't take the pressure the on-site guys take. You need to have a way to know something is important, so it's important to be constantly pairing with your on-site peer.

Another thing is off and on if the company has an on-site team and a remote team, they tend to not give the right value the remote team deserves. They don't see the remotes working, so you have to find another way to build up trust. Again, over communicate and keep mentioning what you are doing, one or two times a day doesn't hurt. Another idea is to improve a bit the company's process to use documents because it's easier to just people talk to each other in the office and not pass the information to the remote folks.

Organization

One of the most fundamental problems of working remotely is organization. It's OK to not be much organized at the beginning. But after some time your own body starts to ask for that.

Not only your body, actually, but your family, friends, and every other aspect of your life. You need a routine, the proper times for eating, waking up, starting and stopping working. The more you so the same activities at the same time every day the better.

We tend to forget we are working and don't stop. Or procrastinate, play PS4 too much and don't work. Another very essential point, at least to me, is clothes. As I said above, I need wearing “work” clothes and “home” clothes. This tells my brain I'm in a working or home state.

Track time

Tracking time is the best way to help with organization, and also will help with estimating future features. The tracking tools can provide fascinating reports about the time spent in a feature, talking to a person, etc. Besides allowing you to not lose when you should stop working and take some rest, this is a valuable information that can help you in the future.

Health

Following the previous topic, there is a constant need for equilibrium, so let me mention here doing something without a computer is very important. Every remarkable person we know implements that.

If we found it boring, we should keep searching until we encounter something fun. I always hated the gym. Bought a bike, a guitar, and Muay Thai gloves and those are working for me.

Family time, friends, contact with nature, everything helps.

Why am I saying all that? Remember we are working remotely, most of the time alone, so it's straightforward to lose track of the world and just stay at home all over the month. A plan of action of how to stay in balance is required, so we can perform our best in our job and also give the deserved attention to family and friends, our body, mind, and health in general.

Communication

Overcommunication is the key, IMHO. If you have a productivity app like Slack to talk to other devs or members of the project, make sure to explicitly say when you start, leave for lunch or do other things and stop.

If you work isolated and the communication is typically after some days and/or via email, make sure to keep sending emails, following up, asking for answers, send information in advance before being asked, etc.

If you are between asking or not, ask. Never assume someone knows about something. Most of the conflicts that happen in a remote environment are due to the lack of communication.

I'm still working on this, that's the part, after eight years, I'm not so good at. If I have to rate my communication, I'd say it's 85 out of 100. I need it to be 110 or 120, then I am sure I will be over communicating enough to avoid any problems or confusion.

Final words

Of course, many situations here really depend on the kind of job you have. If you merely perform your tasks and work mostly alone or asynchronously, it's OK to be in noisy environments for instance. If you are an employee working at home, that's completely different. When you participate in meetings, pair programming, lots of planning and video with coworkers, you need a different setup.

I hope this post could help not only the ones that want to start working remotely, but also everyone involved in the remote world, and if you have any question or disagree with anything, I'm happy to talk :)

Thanks so much.

Thanks Ron Timoshenko and Niqui Merret for their opinions and experiences about remote work, which contributed to making this post better.

Resources

Over here are some valuable resources about remote work:

https://www.toptal.com/freelance/how-to-work-remotely-and-still-be-the-best/#book-tested-programmers
https://www.toptal.com/remote/staying-healthy-while-working-remotely/#book-tested-programmers
https://www.paymoapp.com/blog/working-remotely/
https://youteam.io/blog/remote-development-team-guide/
https://youteam.io/blog/guide-to-hiring-remote-team-of-software-developers/
https://x-team.com/blog/10-secrets-to-becoming-a-great-remote-developer/
https://auth0.com/blog/21-tips-for-remote-working/
https://blog.codinghorror.com/on-working-remotely/
https://dev.to/lefebvre/what-ive-learned-after-working-remotely-for-10-years-384j
https://www.codementor.io/learn-programming/8-tips-to-become-an-effective-remote-developer
https://www.deekit.com/11-things-about-remote-work/
https://medium.com/swlh/effective-tips-for-working-remotely-23cc290a8c08
https://www.wordstream.com/blog/ws/2017/06/16/working-remotely
https://skillcrush.com/2017/06/05/remote-work-from-home-skills/
https://skillcrush.com/2016/10/10/working-remotely-tips/
https://blog.trello.com/company-remote-work-myths
https://news.ycombinator.com/item?id=16482351

Finding remote work

Below is a list of places to find remote work:

Toptal - https://www.toptal.com/#book-tested-programmers
Hackhands - https://hackhands.com/
Remote OK - https://remoteok.io/
Upwork - https://www.upwork.com/
BairesDev - https://www.bairesdev.com/
AngelList - https://angel.co/
Remote.com - https://remote.com/
Codementor - https://www.codementor.io/
Indeed - https://www.indeed.com/jobs?q=developer&l=remote
Dice - https://www.dice.com/jobs?q=&l=remote
Vibbra (PT-BR) - http://www.vibbra.com.br/
Torre Jobs - https://torre.jobs

Hi, I'm Ivan. I grew my career while working remotely since 2010, I love knowledge sharing and helping starters. AMA!

Ivan Neto — Fri, 18 May 2018 14:53:25 +0000

What I'd like to hear from an experienced developer when I was a beginner

Ivan Neto — Fri, 04 May 2018 05:53:09 +0000

When we are just students, getting our first jobs, many questions come to mind:

What programming language should I learn?
Should I pursue a more scientific oriented career?
What are the types of jobs related to the technology I want to work on?
Where to work? What kind of company?
What has changed recently?
And many others...

Such questions are normal and healthy at that time. We have to make a lot of personal and professional decisions during life. In this post, I will show decisions I made, my opinion about key issues and share some interesting cases that happened to me. Things I'd like to hear when I started.

Programming Languages

This is indeed one of the most asked questions. Should I learn Java? Python? C? Ruby? JavaScript? XYZ? Should I learn all languages in the world?

Do languages matter?

Short answer: No.

Fair answer: Yes and no. They matter to learn their differences, paradigms, how they implement object orientation, design patterns, how they deal with memory and the OS. After some time, they are merely tools that you learn how to use in one day or two. You'll probably stick with one, work a bit with another, and have fun with two more. In the end, it's just a matter of choosing the right one for the appropriate job.

A couple of years ago I learned Python and a friend of mine, Java. He got a job quickly, and I didn't. I genuinely liked Python and he chose Java in order to find jobs. I could get a very good job and enjoyed it. If I had quit, it would have been difficult to find another one, though. His job wasn't that good, but he could quickly find another job. There is an inevitable trade-off.

Technologies

What I'd say about technologies is about the same, but as soon as you narrow down your knowledge to some area, there are categories we could easily fit each of the ones we'd want to learn. They represent essentially technologies that:

We work with;
are related to the ones we work with;
complement it;
we just want to play around with them;
we find an opportunity to learn them.

As a web developer, I worked with Python language, Django framework as related technology, MySQL, PostgreSQL, Redis, JavaScript to complement my work. That was typically my stack. I played around with Swift because I wanted to learn iOS development and I had an outstanding opportunity with Pyramid.

Opportunities

One of the most significant things about a professional is its rarity. Technologies play a critical role regarding the transition between keeping looking for jobs and being disputed by companies.

There are many Python developers around. Not so many with experience in OpenCV and OCR related technologies. In a certain company, there was a chance to work on a modest project to detect dirty and broken walls in a room. The dev chose to work on it so now she remains as part of this group.

Whenever I have the chance to grasp something new or do things others devs refuse to, I'm very inclined to do so. The consequences of accomplishing that are often extraordinary. Once I learned a legacy system only one guy maintained and when he went on vacation I could take over. Bit by bit, I took the "legacy system maintenance" role from him so he was finally released to do more important stuff and I became essential as well. When we had to remodel it, I knew most of the company's business rules.

Another primary thing that assists the process of learning faster is code reviews. Even if you are a Jr dev, go ahead and review a Sr dev code. Just ask questions about implementation, approach or business rules. Next run the code locally and play with the changes. Inspect modules, classes, function returns. This improves considerably with your growth anywhere.

Market

Keeping an eye on what's going on with the market is also a very good step towards increasing the chances of getting more opportunities and being a rare professional. The company and the job request from you, but the market also does.

If we go from 2000's until now, it's possible to follow the evolution of the web, for instance, and the arising of many jobs related to adding rich apps, audio, and video. We saw the advent of the smartphones and we could specialize in mobile apps development. We also had a front-end boom, with many possibilities of JavaScript frameworks, chat and home automation, big data, data science, and more recently, we have progressive web apps, cryptocurrencies, and blockchain.

Additional Questions

Should I try a more scientific career?

It really depends on your background. If you already had the experience of working on a paper and submitting it to a journal or similar, that makes things easy. Or if you like data analysis, it's possible to find hybrid jobs.

What are the developers "rank"?

That's not well defined. The following posts may help:

7 Ranks of Coderhood: Coder, Programmer, Computer Scientist, Developer, Engineer, Architect

Lorenzo Pasqualis ・ Nov 30 '17

#career #code #programming #skills

19 Types of Developers Explained

Lorenzo Pasqualis ・ Oct 19 '17

#career #beginners #industry

Corporate or Startup?

You should try both and see which one is the best fit for you. I tried startup first because I could have more freedom and work in different areas I wouldn't have the opportunity to work in a big company. I talked to clients, gave presentations, gathered requirements, implemented solutions, deployed, worked even at the financial part of the company.

Should I consider a remote job?

For sure. I have been working remotely for seven years, and part of Toptal for four years, and I say it's really straightforward to find a remote job. Even non-tech companies are starting to allow remote employees, and it's working well. Some hire remote for a period of time, some have a remote and an on-site team, and some are constituted by only remote people. Even the CEO!

If you want to pursue a remote career, be sure to follow this.

Below is a list of places to find remote work:

Toptal - https://www.toptal.com/#book-tested-programmers
Hackhands - https://hackhands.com/
Vanhack - http://www.vanhack.com/
Remote OK - https://remoteok.io/
Upwork - https://www.upwork.com/
BairesDev - https://www.bairesdev.com/
AngelList - https://angel.co/
Remote.com - https://remote.com/
Codementor - https://www.codementor.io/
Indeed - https://www.indeed.com/jobs?q=developer&l=remote
Dice - https://www.dice.com/jobs?q=&l=remote

That's it

This post has a lot of my opinion and past experiences, but I hope it helped in some way. If you disagree or would like to discuss any specific topic, just comment and I'm happy to talk. Thanks. :)

Delivering in time is a matter of observing the details

Ivan Neto — Sat, 23 Dec 2017 08:45:24 +0000

After seven years of experience with software development, different companies and technologies, having as consequence experimented many methodologies to manage work and teams, I could see that regardless of the process your team has, you'll find yourself with problems to deliver.

One big contributor to the failure of most of the software planning is the waste of time. We tend to spend more time than we should in many situations and the total time lost is big enough to affect the project.

From my experience, the situations are mostly related to communication and represent a big bottleneck:

People waiting for answers or decisions regarding a changed spec;
Tasks being blocked by other tasks;
Lack or slow communication.

This week I was working on an important task that had a requirement change one day before the deadline. A small change, but with two text options and we had to wait for the Project Manager to decide.

The waiting time wasn't so big, but enough to create a Butterfly Effect and delay the task in one day (conflicts, new bugs in other tasks, QA started later, new deploy in another system being queued before, etc). We could have solved the issue by simply creating a flag or A/B test based solution where we could just deploy and then enable the first or the second text based on the PM's answer. The cleanup would certainly take less than the waiting time.

Here are some examples that may improve your team ticket and processes' flow:

Example 1 - Slow communication

Developer finishes a task, submits a PR (Pull Request) and doesn't tell people there is a new review to be done.
Reviewer finishes a review and doesn't ping back the developer to perform the fixes.
Reviewer approves a PR and doesn't ping the QA person to start the testing.

Sometimes people think the others will get notifications and will act promptly. This doesn't happen. They will do only after three, four hours or even one day after.

Solution: create a culture of always communicate to all involved whenever there is a change to the task state, using the team's main communication channel.

Example 2 - Waiting for a decision

There is a decision to be done and the developer is waiting.

Solution 1: try to imagine what would be the most appropriate choice, choose it and work on it.
Solution 2: make both work behind an ON/OFF switch.

Note: The solutions above highly depend on the scope of the decision .

Example 3 - Waiting for another system

There is an API endpoint for another system that needs to be finished before the developer can complete the task.

Solution: Split the task in two. The first task will log instead of calling the API. The second task will replace the log with the API call.

Example 4 - Waiting for ticket

There are no new tickets to work.

Solution: Code review, pair with another dev.

Example 5 - Developer is taking too much time in a ticket

Sometimes there are tickets bad specified and we end up with one developer working alone for a long period of time.

Solution 1: Split the ticket into non-technical subtasks as much as possible, so other developers can pick each of the subtasks.
Solution 2: Split the ticket into technical subtasks containing deployable pieces. The feature can then be activated after the last piece is pushed (For instance, we can have a task to perform a database change, another to add a new HTML template, and finally, one including one URL with some app logic, showing the page and using the new database updates).

Note: in this particular case solution 1 and 2 can be perfectly done together. Instead of one big ticket, for instance, we could have three subtasks, each one with three technical parts, and many developers could work on it instead of just one.

Example 6 - QA is holding some part of the process

QA has to test everything and is slowing down the process

Solution 1: Some pieces can be pushed and skip the QA process, like a template file that will not be used until the final feature is done.
Solution 2: Even business logic pieces can make use of A/B test flags, and if they are pushed turned off by default, QA can do a small test just to verify nothing is broken and the real test can be done later.

Example 7 - Bugs found in pre-releases

A bug is found in a pre-release and a fix is needed.

Solution 1: Fix the bug, of course.
Solution 2: If the bug only happens when a flag is inactive, deactivate the flag, so you unblock the push and then you can work on the fix and do a second push.

Note: solution 2 can only be done if the flag is new and is going to the next release.

Example 8 - Work depending on a still open PR

The developer has to work on a new task, but it depends on a PR still under review.

Solution: Create a branch on top of the branch under review. Most developers here tend to say he/she is blocked and waits. There is no reason to wait. Work on top of the previous work, that's it. When the PR is approved, rebase.

Example 9 - Someone is blocked. You are blocked

Solution: Ask yourself: what do I need to do to unblock her/him? What do I need to do to unblock me?
People like to say "I'm blocked" or "I'm blocked by someone/something" and do nothing about it. It's comfortable. There is an excuse. You have to be able to say "hey you can do X, Y, Z, done, you are unblocked".

Starting to change is hard but it pays off. In the beginning, you really have to keep monitoring everybody, detecting when every "time waste" situation happens, and work hard to unblock people.

When you start to feel they are doing by themselves, i.e., it is becoming a habit, you can certainly expect more successful deliveries anytime soon. Remember: your job as a developer is not only writing code, but deliver value.