My thoughts about life, cars, startups, and weight lifting.

Category: Uncategorized

Oatfin Selected for Google For Startups Founders Academy

We are super excited to announce that Oatfin will be part of the Google For Startups Founders Academy! At Oatfin, our mission is to enable software engineers to deliver cloud applications faster through self-service automation. We do for software engineers what self-checkout does for retail stores. We enable them to be more agile and remove dependency on platform teams to deliver cloud applications.

The Google For Startup Founders Academy begins on March 3rd and consists of hands-on workshops across a range of topics including customer acquisition, hiring, fundraising, and tech enablement. We are one of 50 high-potential startups that the Google for Startups team selected for the first nationwide cohort. Last year, it was piloted in Atlanta with 45 Georgia based companies.

With Google’s advanced technologies and their sophisticated ecosystem of cutting edge tools, we are excited about how that will help us further our mission. We plan to leverage Google Cloud to further enable developers to deliver cloud applications faster.

Login With Github – Flask/React

While working on Oatfin, one use case we just finished implementing is using Github to allow users to sign up and login for the app. Users can now easily login with Google, Github, and Gitlab.

Our default login is also password-less meaning a user can login with just an email address. We send the login link directly to the email. This adds a layer of security because the user has to have access to the email to login and also validates that the user is a real person. Another problem password-less solves is syncing users from different sign in providers. We can guarantee a user who signed in with Google is the same user from Github or Gitlab.

Our app uses React with Typescript on the front-end and Python, Flask on the back-end. Here is what it looks like.

Part one is to create an OAuth app in Github as explained here.

Part two is setting up the React/Typescript component. When unauthenticated users visit the home page, they are redirected to the login page. That should be your application’s default behavior already.

When users click your ‘Login with Github’ button, they are first sent to Github’s login page with the scopes you want and your client_id like this:


const onClick = async () => {
    window.location.href = 
    'https://github.com/login/oauth/authorize?scope=user:email&client_id=YOUR_CLIENT_ID'
  }

After visiting Github’s website and they login, Github redirects back to your call back page which might still be the login page in our case. In your callback url, there is a now parameter ?code=some_code_text.

Your goal now is to take the code returned from Github and pass it to the Python/Flask app. My login component looks like this:


const Login: React.FC<{}> = () => {
    // ...
  useEffect(() => {
    // see if code was returned, returns an error if the user denies the request
    const newUrl = window.location.href;
    const hasCode = newUrl.includes('?code=');

    if (hasCode) {
      // get the code value
      const url = newUrl.split('?code=')[1].split('#/login');
      const data = {
        code: url[0],
      };
      // send the code to the backend
      submitGithub(data as LoginParamsType);
    }
  }, [submitGithub]);


  const onClick = async () => {
    window.location.href = 
    'https://github.com/login/oauth/authorize?scope=user:email&amp;client_id=YOUR_CLIENT_ID'
  }

    return (
          <Button onClick={onClick} 
            Continue with Github
          </Button>
    )
}

Here we take the code and call the API, which returns access token to store in localStorage.


const submitGithub = async (values: LoginParamsType) => {
    try {
      const res = await accountLogin({ ...values });
      if (res !== undefined &amp;&amp; res.access_token !== undefined) {
        window.localStorage.setItem('oatfin_access_token', res.access_token);
    } catch (error) {
      message.error('Unable to login with Github.');
    }
  };

Part three is the Python/Flask login API. We make 2 calls to Github: first to exchange the code we got from the front-end with an access token, then to use the access token to get the user details.


import requests

@api.route('/login', methods=['POST'])
def login():

    req_data = flask.request.get_json()
    code = req_data.get('code')

    if code:
        data = {
                'client_id': app_config.GITHUB_CLIENT_ID,
                'client_secret': app_config.GITHUB_CLIENT_SECRET,
                'code': code
            }
        # exchange the 'code' for an access token
        res = requests.post(
            url='https://github.com/login/oauth/access_token',
            data=data,
            headers={'Accept': 'application/json'}
        )

        if res.status_code != 200:
            raise UnauthenticatedError()

        res_json = res.json()
        access_token = res_json['access_token']

        # get the user details using the access token
        res = requests.get(
            url='https://api.github.com/user',
            headers={
                'Accept': 'application/json',
                'Authorization': 'token {}'.format(access_token)
            }
        )
        if res.status_code != 200:
            raise UnauthenticatedError()

        res_json = res.json()

        names = res_json['name'].split()
        first_name = names[0]
        last_name = names[1]
        login = res_json['login'] or res_json['email']
        avatar = res_json['avatar_url']

        # create the user
        user = UserService().create(...)
        access_token = create_access_token(identity=user.json())

    return flask.jsonify(
        access_token=access_token
    ), 200

Oatfin – Painless Cloud Infrastructure

If you’ve ever had to deploy an application in the cloud, then you know the pain of cloud infrastructure, whether that is AWS, Azure, or Google Cloud.

The process is not only manual and tedious, but also time consuming. While there are some solutions like CloudFormation and Terraform, it’s very painful to write and deploy these scripts. You now have to maintain more code just to deploy your application in the cloud. At Oatfin, we’ve been working on solutions to make cloud infrastructure painless.

As a software engineer, I have always wondered why the cloud has to be so painful. Why can’t I push a button and have my application be deployed on AWS for example? And once I’ve deployed my application, why is it so hard to scale, secure, and monitor it? This should not be so hard in the modern world of web applications, but it is.

Oatfin enables companies to deliver cloud applications faster by helping transition from manual processes to self-service automation. Our app empowers teams to deploy, monitor, scale, and secure their apps quickly without having to write manual scripts that can take weeks. In addition, it also has many features to help a developer get code live in production and testing as well as zero downtime updates and one-click rollback using versioning.

How Oatfin Works

We are in the process of automating more, but right now the app first creates build artifacts and pushes them to S3 or a docker registry (Gitlab, Github, or Amazon’s Elastic Container Registry, ECR) in the case of docker containers. This works with the front-end and back-end APIs. In the case of front-end, we can either push the generated code to CloudFront or create a docker container with standard Apache/Nginx to serve the files.

We currently have a demo API using python with flask and celery, which uses Gitlab pipelines to create multiple containers. We’re working on providing more examples for other frameworks.

Users can also define docker images using the app:

Add a container image

Here we see the list of containers:

Container images

Once a container is added, a user can then create a cloud infrastructure application and deploy it on AWS for example in less than ten seconds.

To create an infrastructure, a user specifies the name, description, a virtual private cloud (VPC), the type of infrastructure, and finally the container image to deploy.

The app creates the underlying infrastructure which includes two security groups, a load balancer, a target group, an auto-scale policy, a log group, an ECS cluster, a service, and a task definition.

Create application infrastructure

The final step is to deploy the app. As part of deploying the app, the final step is to run the task. That’s all! The app is now scalable, secure with logging and monitoring.

Deploying an application infrastructure

Here we see the list of infrastructures we’ve created

List of application infrastructures

Launching Oatfin

Oatfin Demo

Oatfin enables companies to deliver cloud applications faster by helping transition from manual processes to self-service automation.

Our app empowers teams to deploy, monitor, scale and secure their apps quickly without the overhead of writing and maintaining manual scripts which can take weeks. We started with automating AWS and Google Cloud Platform and making it a lot simpler to deploy, scale and secure a cloud infrastructure. Our grand vision is to take the data and learning to build a simpler cloud.

As a software engineer myself with over ten years experience, I’ve always been frustrated with the current solutions whether that is AWS’s web console, CloudFormation, Terraform, etc.

I didn’t set out to build Oatfin as a cloud infrastructure automation platform. Two years ago, I started working on a FinTech product to connect lenders and wholesale brokers, but I realized I didn’t have the finance knowledge required and if I wanted to continue down that path, I would need to get an MBA or find someone with finance experience to work on it with me. I connected with a lot investors and startup accelerators, but nothing materialized.

I took a break, worked and consulted for many FinTech and healthcare startups and that’s where I really started thinking harder about cloud infrastructure. Everywhere I worked at, cloud infrastructure was a major recurring problem. Some examples:

  • 3–4 Months to deploy an infrastructure and onboard customers
  • $10,000+ in cloud spend a month
  • Lack of visibility into the apps
  • Security
  • Logging and monitoring
  • Lack of technical support
  • Expert knowledge of networking/infrastructure
  • Manual, tedious, and time consuming process

What eventually formed the basis of the app was a simple python script I wrote to automate my job at a FinTech startup. The app uses Flask with Celery as a distributed task queue backed by MongoDB and ElasticSearch while the frontend uses React with Typescript.

How To Find Users Using Job Boards

It goes without saying that selling is hard and most of us are terrible at it. What’s worse is a lot of platforms exist to sell us ad premiums that return no value. For example, a few years ago, I was working on an app and I was desperate to get users and to show people what I was working on. I put some ads on LinkedIn, Facebook, and Twitter. The ads were cheap, but it was a complete waste of money. No one came to my website.

If you follow Hacker News and Paul Graham, one of the things he mentions is you have to do things that don’t scale at first. For example, the Airbnb founders were on the ground in NYC talking to their users and actually helping them take better pictures in order to make the website more appealing to users. This is also true for Stripe when they started. They processed a lot of things manually until they had a good handle on payment infrastructure.

While working on Oatfin, a cloud infrastructure automation platform, one of the things we’ve been doing is going through job boards and finding companies that are looking for DevOps, DevOps Manager, AWS Architect, etc. This has been a huge help for 2 reasons. One, by reading the job postings, we understand the kind of company we’re targeting, the kind of challenges they are facing, who their customers are, and most importantly how they make money (and how we can help them make even more money.) Second, we can develop a rapport and tailor our message to pitch our product.

This has been pretty helpful at least to us so far. I hope to write some more and share more learning.

Cheers!

Bringing The Blog Back

Just getting my blog back up so I can write about things I find interesting! The last few years have been a period of high growth and learning. One of the best things I did was getting off social media in general and instead spending more time in the gym, reading, meditating and learning. I recently tried to resurrect my LinkedIn profile only because otherwise people don’t think I exist.

Today I finished reading the book, “The Instant Millionaire” which I found very interesting. It’s about a young man who despite several disappointments and setbacks, sets out to become a millionaire. He meets an old gardener who gives him the formula to become an instant millionaire.

I also recently read “The Alchemist”, along the same lines. The book is about a shepherd boy who yearns to travel in search of a worldly treasure as extravagant as any ever found. He meets an Alchemist who guides him on his journey.

There are several key messages in these 2 books and perhaps, the most important one as stated in “The Instant Millionaire”, is:

“When the student is ready, the teacher will appear!”

The opposite is also true. If the student isn’t ready, the teacher will never be able to convince the student. Instead, they will become each other’s nemesis. The student has to set out in search of the light and also be in a state of acceptance! It’s worth saying the teacher could be a 5 year old and the student a 60 year old and vice versa. While the acceptance state can start anytime, it can be influenced by involving the subconscious mind. Once the subconscious mind accepts the message, it’s then easily executed by the conscious mind.

This message rings true in just about every walk of life. It’s also the source of every human struggle as illustrated by the story of Jesus in the Bible. When the teacher shows up before the student is ready, it causes a struggle between logic and emotion whereby emotion always wins!

When I set out to become stronger several years ago, I had no clue what I was doing in the gym, but I was “lifting.” Should someone tell me I was doing something wrong, I would be pissed at them! It’s only recently that I learned to lift properly having picked up the book, “Starting Strength”.

Back to the lessons in these books, the most important message is:

“Financial prosperity and a fulfilling life are goals we can all achieve if we understand the principles of success!”

I just started reading “Choose Yourself!” I’m hoping to write more about these books. Hopefully soon! Cheers!

© 2021 Jay Paulynice