Tech startups are on a quest for the ultimate app, a digital creation that propels their business toward success. They navigate through uncharted waters, using data as a map to chart their course and make corrections along the way. With a fresh, innovative approach to product development, startups have caught the eye of both software vendors and clients.

Embark on a journey with Lexis Solutions as we delve into the exclusive realm of [software development](https://www.lexis.solutions/services/next-js-development) for startups. Uncover the key phases and models of product building that every tech entrepreneur should be familiar with and put into practice for optimal outcomes.

## Software development for startups

Software development for startups is distinct from established corporations due to its limited market influence and financial resources. 

## Critical differences in software development for startups

### Agile response to the transformation 

Flexibility is crucial for success as a young business entering a competitive market. Startups should have a business strategy adaptable to market changes instead of sticking to a rigid plan.

### Ability to pivot quickly

The ability to rotate easily also allows startups to shift, making significant changes to their business direction without incurring substantial losses or failing.

### Attention to clients' insight

Unlike larger businesses with extensive field experience, startups must pay extra attention to customer feedback in product development. With a smaller consumer pool, startups can gather more specific, actionable insights directly from users.

### Analytics-based strategy

Like other aspects of the business, software development for startups must be data-driven. Although companies of all sizes rely on data, startups need to build data sets for each product they develop to avoid the buildup of data silos, a common issue in more giant corporations.

## The phases of software development in startups 

Following a structured process is essential to ensure a smooth journey from idea to deployment and beyond when developing a new product. The steps can be adjusted based on your needs or deadlines. 

### It all starts with an idea

Unleashing creativity in a team environment requires tapping into the collective imagination. Capturing each unique thought and storing it for posterity is vital. Subsequently, the most promising concepts come to light by evaluating and narrowing down the choices and delving into market trends, granting a deeper understanding of the landscape and the players. Conducting a SWOT analysis allows your startup to chart a course for success.

### Bringing an idea to life requires thorough validation

This includes outlining your competitors and monetization strategies and showcasing a minimum viable product (MVP) to highlight the software's fundamental functionality. Engage with your [CTO](https://www.lexis.solutions/blog/cto-as-a-service-the-ultimate-guide), partners, investors, and stakeholders to ensure your concept is sound and backed by a solid business plan.

### Crafting the vision

Your design team paints a vivid picture of the software to help developers bring it to life. With the help of your [UX/UI](https://www.lexis.solutions/blog/free-resources-for-resourceful-UI-designers) specialists, wireframes and prototypes of the user interface come to life. Engineers then evaluate the feasibility of the features before building the product, seamlessly integrating ideas with the business plan.

### Building the foundation

The heart of software development for startups lies in this stage. It requires focus and skill, whether enhancing the MVP or starting from scratch. Agreeing on the tech stack sets the foundation for your development team to begin constructing the product.

### Testing the waters

Separating testing from the development process can speed up the [quality assurance](https://www.lexis.solutions/blog/into-the-shoes-of-a-QA-the-FAQ) (QA) process. Instead, integrate testing into the software development life cycle to identify and fix bugs before moving forward.

### Bringing it to life

Once testing is complete, implement the changes. Review the code and make any necessary modifications before adding new features.

### Launching into the world

It’s time to launch. Your DevOps team should have a plan to deploy the product. This is crucial as it's the first time your solution meets the target audience. Showcase your startup in its best light, gather user feedback, and make adjustments.

### Monetizing the dream

Before launching, determine the monetization strategy that aligns with your marketing plan and maximizes profits while prioritizing a positive user experience. Choose from various options, such as subscriptions, in-app sales, ads, purchases, and sponsored partnerships.

### Continuous improvement

The software development journey never truly ends. Keep a close eye on the product, gather user feedback, and continually make improvements. Maintain a strong relationship with your users and stay open to their suggestions for future updates.

### Models of software development for startups

The world of software development for startups is constantly evolving, with new methodologies emerging to help teams build better and faster. But which one is right for you and your startup?

__Agile is the king of flexibility;__ with short-term deliverables and iterations, startups can quickly iterate their products without restrictions. However, Agile can lead to poor resource allocation and may disregard documentation.

On the other hand, __Waterfall__ follows a strict chronological hierarchy and prioritizes documentation. While this method is simple to follow, even with shifting team members, it may limit the agility of the software development process for a startup.

__Lean__ values efficiency and swift product delivery. This methodology optimizes resources and empowers team members to be more productive but relies on seamless cooperation between teams.

Each method has its advantages and disadvantages, so it's essential to carefully consider your project's needs and goals before deciding.

## How to find software developers for a startup

Recruiting the right developers for your startup can be a game-changer, but simply telling them, "I'm building a billionaire business, want to be part of it?" won't do the trick. Here are some steps to help you bring on the right talent to build your dream:

### Clarity 

Define the essence of your project and what it entails to convey its worth to potential developers. Passion and a clear understanding of your idea can be your best selling points if you need a millionaire investment.

### Talent over budget

Don't settle for just anyone who fits your budget. Dedicate time to sourcing and recruiting the right candidate with the skills and excitement to work on your project.

### Know what you need 

Be transparent in your job description and ensure it reflects the flexibility required for a role in a startup. Knowing the different types of developers and their areas of expertise is especially important if you need a technical background. Hiring someone who needs to be the right fit can only delay projects and harm morale.

### Embrace remote work

Attract top talent from all over the world by considering remote work. Hiring remote developers can save time and money and accommodate a more efficient workflow.

### On a quest to hire developers for startups 

For those looking to bring a developer on board, freelancing platforms are a popular option for single projects. Toptal, Guru, [Upwork](https://www.upwork.com/ag/lexissolutions/), Freelancer, Fiverr, PeoplePerHour, and Lemon.io are well-known freelancing websites. 

Another strategy is to partner with local universities, sponsor student projects to find up-and-coming talent, and then offer internships to help students gain experience and connect with your company.

Job boards like LinkedIn can be a fast solution for finding developers online. However, knowing the right fit for your company can take time and effort with so many candidates. Local recruitment agencies can save time in the long run, but they limit your search to one area and may need more technical knowledge.

Another crucial question is how much it costs to hire developers for a startup. And the answer is not that simple: it depends. We already gave you some options for how and where to find the right developers for your startup. A tech partner is always a good choice, especially a [Chief Technology Officer](https://www.lexis.solutions/blog/cto-as-a-service-the-ultimate-guide). If neither of them works, you can always ask a fellow startup founder, who you are sure is on the way to success, for any significant advice. 

## The blueprint for a better process of software development in startups

### Communication is the key

Ensure a harmonious workflow by creating crystal clear channels of communication. Utilize tech-savvy tools like Slack to facilitate seamless collaboration between team members. Schedule frequent virtual huddles to stay in the loop and easily track progress.

### Stay focused on your goals

Use [project management tools](https://www.lexis.solutions/blog/scrum-a-comprehensive-overview) and [extensions](https://www.lexis.solutions/blog/7-google-chrome-extensions-for-higher-productivity) to track progress and ensure you stay on track with your launch timeline. Regularly evaluate the project to ensure it aligns with your initial goals.

### Choose your [resources](https://www.lexis.solutions/blog/free-resources-for-resourceful-UI-designers) 

Wisely before selecting a technology stack, and provide you have experienced developers on board. Consider hiring new developers or outsourcing part of the work, but always have in-house [experts](https://www.lexis.solutions/blog/cto-as-a-service-the-ultimate-guide) to handle integration.

### Document everything

Centralize all product development documentation in a system. This will prevent delays and keep the project moving forward even if team members leave mid-way.

### Data-driven decisions 

Make decisions based on data, not intuition, to minimize the risk of failure. Use data management systems like [MongoDB](https://www.lexis.solutions/blog/What-is-MongoDB) to analyze information and make informed decisions. Automate data processing to get real-time information with high accuracy.

### Test, Test, Test

[Testing](https://www.lexis.solutions/blog/how-to-test-REST-ful-APIs-with-postman) is crucial to catch errors and logic flaws in the code. It's a time-consuming process, but the stakes of a flawed code make it worth it. Make testing a part of your software creation process, or give it its life cycle.

### Seek feedback

As we already mentioned, considering your clients' insight is crucial.

Conduct surveys, questionnaires, and usability tests, and observe customer interactions to gather information and improve your chances of success.

## Conclusion

Bringing software development for startups to life may seem daunting, but by sticking to the essentials, you're building the cornerstone for future triumph. Pick a startup-savvy method that keeps you light on your feet and can pivot with the market's demands.

Though many companies and startups are hopping on the agile bandwagon, select a software development model that suits your startup's unique style. Thorough testing is a must-have, so give your products a [complete workout](https://www.lexis.solutions/services/react-development) before unleashing them. 

Communication is vital, so keep the channels open and harness the power of tools to be more productive, gather valuable user feedback, and make smart business moves.


Join Lexis Solutions on a journey to the heart of software development for startups and uncover the secrets to success.

software development for startups

From Idea to Launch: Software Development for Startups

bubble.io-cover photo

DigitalOcean Announcement

Bilyal Mestanov

Antoniya Ivanova

deployment-cover photo

pexels-photo-4974922

Nikola

Stefan Mitov

Ivan Todorov

Radoslav

the manifest cover-phoot

cypress-cover photo

Deyan Denchev

AI-instruments-2

Mira

guzzle

CTO & Co-Founder

Nikola Popov

PHP / LARAVEL / DATABASES / SASS

Radoslav Kosev

QA Engineer

Full Stack Developer

CEO & Co-Founder

Software Developer

Mira Ereeva

Growth Manager

PHP Developer

## Automation QA's tests before having programming knowledge

## More focus on test design and application understanding

In the world of automation QA, when we first start, and we don't know much about programming, we mainly concentrate on really understanding the application as if we were the customer. This helps us create tests that act just like a regular person using the software, making sure we check it thoroughly in all kinds of situations. Of course, even after we learn programming, our dedication to understanding the application remains. But here's the important part: knowing how to code helps us do an even better job. We can create more advanced tests and make our testing methods more precise and efficient. This way, we keep testing the application like a real user while using our coding skills to do our job correctly.

### Preference for user-friendly automation tools

Additionally, testers with limited programming skills often prefer to stick to user-friendly automation tools with more intuitive interfaces that would require a minimal amount of coding, allowing them to create automated tests more quickly. One advantage here is that they can begin without facing the challenges related to programming languages, which is quite a time saver and lets them dive more into their field in detail.

### Preference for simple testing apps that offer test scripts

QAs who test software without knowing how to program often rely on online testing tools that record and save actions. After a test is registered, it can usually be modified so it can change what you do during different steps and also change the expected result. Such tools copy your interactions and record them in a way that's repeatable and faster than manual work. Later, they can modify them as you please, or you can create your own from existing samples. While they don't write code, we still make the most of what's already available to test software effectively. It's good to note, though, that generally, such online testing tools don't go beyond testing websites only.

### Reliance on regular collaboration with programmers

Given their limited programming expertise, testers often must collaborate more closely with programmers for help. This collaboration becomes essential for addressing script issues and inconsistencies and also handling more advanced automation tasks. 

Working closely with developers can be a valuable learning experience. It ensures that even if you lack programming skills, with enough effort - you can meet development standards and nurture devskills over time. Not to mention that when you start performing your tasks individually - programmers on their own don't have to worry about finding time to fix what you write. They focus on their part, you focus on yours, and productivity increases immeasurably. 

## Benefits of having programming knowledge

### Enhanced test-building skills

Having programming skills equips an automation tester with the ability to build sophisticated and comprehensive test scripts. They can create test scenarios that cover a more comprehensive range of inputs and conditions, resulting in more thorough testing. Additionally, the possession of programming skills allows testers to design tests that are reusable and maintainable, reducing the effort and time in the long run.

### Better debugging process

One aspect of testing, where the benefits of possessing programming skills are sure to make quite an impact, is debugging. Why? Knowing how to read code, analyze your test script errors, and identify issues with your strength saves your time, saves the programmer's time, and last but not least - boosts self-confidence. When a test fails, a QA with the above-mentioned "powers" can trace through the code and successfully pinpoint the problem's root cause and fix it efficiently. Self-education in debugging proves to be quite a utility to master.

Better data handling and validation of the software's behavior
Proficiency in programming enables automation testers to handle and manipulate testing data more effectively. How exactly? For instance, they can create scripts that simulate various users and check if a system differentiates between a new user, a premium user, and an admin. Or let's say they have to test an e-commerce website during which every time a user adds three different products to the cart - the price should be calculated correctly. Possessing skills to perform complex data validations and ensuring that the software behaves as expected under other conditions is an absolute must if we're talking about the reliability of test results.

### More effective collaboration with developers

As we can imagine, programming skills can be the way to "bridge the gap" between an automation QA and the developer for natural reasons, from engaging in relevant product discussions to understanding the code and communicating testing requirements clearly. All these mutual activities signify a more explicit workflow that will result in improved collaboration and communication. And on its own, this will reflect positively on every aspect of the working process.

## How the perspective changes with programming knowledge

### Writing less code that would do more

Acquiring programming knowledge transforms an automation QA's approach to test script development. The QA no longer needs to write long and repetitive code for every single test scenario. Instead, the focus shifts to designing functions and test suites that are somewhat optimized and efficient. Also, this will highlight a level of programming "hygiene" (writing less code while achieving broader test coverage), making the automation process better in the big picture.

### Designing more reusable tests/code

Programming knowledge enables automation QAs to design tests and code that are highly reusable. They can create scripts, functions, constants, and custom commands that can be applied to various test scenarios. It is making the test maintenance easier by far. Such focus on the reusability of the tests accelerates the test development process and proves helpful with fast adaptation of eventual testing of new add-ons to the project.
How programming knowledge boosts the prowess of automation QA

### Enhanced test-building techniques

With some programming skills, we QAs can apply applicable practices to our tests. For example, learning a little bit of HTML, CSS, and DOM tree basics is a good start that can help us to choose better elements to interact with. This means that the more you master them, the more logical assertions, combined with the custom mentioned above commands and costs, you will create. Another example from Cypress is including a well-built beforeEach hook that has saved me from writing the same things for more than 100 tests when I can write it as a precondition only once.

### Test efficiency improves

I've discovered that the power of thinking beyond the basics puts a green flag in your garden. From personal experience, I can tell you that testing a payment system does not include only filling in a card number and clicking the submit button. It's also crucial to not forget to test that you won't be able to pay with a non-active card, an expired one, or an empty one. So far, my programming skills allow me to design and execute tests beyond the standard user flow, ensuring that the payment system is thoroughly and creatively tested. 

### Error handling and reporting improve

Testers with an understanding of programming language can handle errors in their code better. As I already started walking that road, I can confirm that knowing to read your own code is a time saver for both you and the developer. And effective error handling, together with clear error reporting, is essential. A responsible QA also understands the importance of reporting errors that appear in the console during testing, even if they're not immediately visible. As we gain knowledge of programming, we start "speaking the same languages" with developers, so we learn to include the proper terminology like "validation," "verification," etc. 

### Test framework flexibility improves

Knowing more about programming helps us save some time in another way as well. Let's say you have to test a sports betting app on Android and iPhone - the user interface might vary with login buttons, input fields, etc., but that doesn't mean it's a bug. So, instead of writing a long script for two separate tests - you can use coding to adapt the script automatically to the respective system being tested. I already applied it to my approach to work, and it aged pretty well, saving me lots of writing.

## Can we, automation QAs, survive without programming?

Programming skills in automation testing are not a must. But when you want to raise the bar and perform different complex scenarios with your testing tool, you simply need them. Of course, you can always stick to manual work for the more complex tasks. Still, if you put effort and brainwork into learning a little programming and reach a level where no scenario is beyond your expertise to write - that's when you win at testing. Think of programming for automation, like having your own beach house. You can still live without a beach house, but having it kind of changes the horizon, doesn't it? So I suggest you consider building your own!

The Lexis' overview of how an automation QA experiences the testing process without any programming capabilities, why they are essential to acquire, how they change the QA's perspective, and whether testers can make ends meet without them.

Programming in Аutomation: Why is it as Еssential as having a Compass in the Wilderness?

Step into the realm of AI innovations once again! Previously, Lexis Solutions introduced you to some of the top [AI-powered tools](https://www.lexis.solutions/blog/ai's-toolbox-the-instruments-driving-innovation-part-one) for videos, content, and images. In this second chapter, get ready to hit all the right notes with a collection of tools for producing the ultimate music, audio, and design masterpieces.

## Music

### AIVA

[AIVA](https://www.aiva.ai/) is the AI-powered composer that crafts unique soundtracks for your every need. Whether for a gaming adventure, a marketing masterpiece, or a special event, this musical prodigy will generate the perfect score. Select a predefined style or upload your sound to guide AIVA's creative flow. 

### Supertone

Get ready to be amazed by the audio alchemy of [Supertone](https://supertone.ai/), the innovative Korean studio that blends art and technology to create music, voices, and more! They're the masters of speech enhancement, song revival, and dubbing - and if you want to hear ABBA singing in Korean, they've got you covered.

### Magenta

[Magenta Studio](https://magenta.tensorflow.org/studio/) comprises a set of music plugins that are constructed upon Magenta's open-source tools and models. Leveraging advanced machine learning methods for musical composition, Magenta is accessible both as an independent application and as an integrated plugin for Ableton Live.

### Orb Producer Suite

Assisting producers in crafting melodies, basslines, and wavetable synthesizer sounds, [Orb Producer](https://www.orbplugins.com/orb-producer-suite/) employs cutting-edge technology to generate limitless musical patterns and loops. These serve as inspirational foundations for musicians to build their creative ideas upon.

### MuseNet

Under the ownership and operation of OpenAI, [MuseNet](https://openai.com/blog/musenet/) can produce songs featuring a diverse range of up to 10 instruments spanning across 15 distinct styles. While MuseNet offers a rich array of AI-generated music for enjoyment, it must provide the functionality to create original music independently.

## Audio

### Cleanvoice 

Introducing [Cleanvoic](https://cleanvoice.ai/)e, the AI-powered solution tailored to enhance your podcasts or audio recordings by eliminating filler sounds, stutters, and unwanted mouth noises. You can easily upload your audio, allow the AI to perform its cleaning magic, and obtain the refined outcome effortlessly. Experience the benefits firsthand with a complimentary 30-minute trial, allowing you to explore its functionality and witness its effectiveness.

### FakeYou

[FakeYou](https://fakeyou.com/) is a text-to-speech generator offering diverse options featuring hundreds of voices. You can effortlessly select any voice and have it articulate the text you input. Whether it's the voice of your favorite actor, singer, or even your cherished animated character, the choices are abundant. It's a creative and entertaining means to prank a friend playfully, wouldn't you agree? And the best part? It's free.

### LALAL.AI

[LALAL.AI](https://www.lalal.ai/) emerges as an advanced AI audio tool, harnessing the capabilities of machine learning algorithms to swiftly and accurately accomplish this task. This exceptional AI system empowers you to effectively extract voices or instruments from audio files while preserving the original quality. By offering a complimentary 10-minute trial period, you can experience its prowess firsthand. Furthermore, another 5 minutes can be unlocked by simply following them on Reddit.

### Uberduck

[Uberduck](https://www.uberduck.ai/)'s text-to-speech technology boasts an impressive selection of over 5,000 expressive voices at your disposal, ready to enhance your voiceovers. This platform goes further by enabling you to replicate your voice. Whether for entertainment – like creating singing or rapping voices – or for professional endeavors, Uberduck caters to both. It's a dynamic tool offering versatile applications, including the creative and the commercial. With subscription plans commencing at just $10 per month, it's an accessible gateway to a world of vocal possibilities.

## Design

### Design Beast

[Design Beast](https://www.designbeastapp.com/Dashboard/Account/Login) is a comprehensive AI-powered design platform that unites many design functionalities into a single hub. Encompassing the Mockup Engine, Logo Factory, Image Editor, Object Remover, Background Remover, and Pixel Perfect tools, this platform emerges as a valuable solution, particularly for those who may not have a design background. Its vast library of pre-designed templates caters to various applications, offering a user-friendly experience. With pricing starting at an affordable one-time payment of $67, Design Beast provides a cost-effective avenue into the world of versatile and professional designs.

### Beautiful.ai

[Beautiful.ai](https://www.beautiful.ai/) boasts an array of customizable templates, a vast selection of stock photos and videos, audio track uploads, and collaborative functionalities to enhance your workflow. Subscription plans commence at $12/month, while the option to purchase individual projects is also available at $45 per project.

### Uizard

[Uizard](https://uizard.io/) can convert screenshots into editable designs and can even automatically transform your sketches into polished designs. Whether your focus is crafting landing pages, designing apps, or creating wireframes, Uizard offers an intuitive and efficient solution with its time-saving features. Uizard's innovative functionality comprehensively addresses your design needs.

### Tome

[Tome](https://tome.app/) crafts incredible presentations as a seamless experience. Enter your prompts into the command bar, and watch as Tome creates mesmerizing slideshows. Whether you're turning strategy papers, creative briefs, websites, or extensive content into engaging presentations, Tome has you covered.

Welcome back to the AI-powered world with Lexis Solutions! 

Innovating with AI instruments - Part Two

As an engineer at Lexis, I would like to share some helpful bits of my experience solving complex business intelligence problems. Recently, I was assigned a rather daunting task of extracting financial information from over half a million documents of financial reports from various companies. This task, though challenging, allowed me to delve deeper into the applications of the more recent AI advances, mainly through OpenAI embeddings and vector databases, for business intelligence problems. How, you ask? Let's take a journey through the process in my comprehensive case study.

## The problem

We were tasked to extract key-value pairs from inconsistent structure and text from business documents. Therefore, we couldn't quickly develop an algorithm to solve the problem and had to implement a solution to leverage the new advances in LLM. We used a cloud solution to train an AI model to extract the key-value pairs. However, it was still pretty challenging to deal with the sheer volume of documents, as not all documents held relevant information, and if we had to process each page, not only would it take more time, but it would be much more expensive. Manually sifting through these documents would be even more time-consuming and economically unviable. The solution? A classification program that combines OpenAI embeddings and ChromaDB vector databases, using Pytesseract for Optical Character Recognition (OCR). 

Before we delve into how these technologies helped me overcome the challenge, let's understand what vector embeddings and vector databases are. 

### Vector embeddings

In a high-dimensional space, vector embeddings are mathematical representations of objects, such as words or documents, capturing semantic meanings based on their context. These vectors provide a way for algorithms to understand the content and context of documents. 

### Vector databases

Vector databases, on the other hand, are databases designed to store and query these vector embeddings efficiently. They enable us to perform similarity search at scale, which is critical in tasks such as semantic search, relatedness search, or, in our example - classification. 

### Implementation

This is where OpenAI and ChromaDB came into the picture. OpenAI provides a powerful tool to generate embeddings for our documents, while ChromaDB allows us to store and query these embeddings efficiently. By leveraging the power of vector embeddings and vector databases, we can classify documents based on how close their vector representations are, which will help us identify relevant pages in a document.

First, I split the PDF documents into individual pages. For each page, I created a MySQL record, applied OCR using Pytesseract, and generated an embedding using OpenAI. Using ChromaDB, I queried the page embedding with the embeddings of already classified pages (that I organized personally) stored in the vector database. The result of the query would give me the most related page to the one I am querying, and I would classify it with the same type, storing the type back in the database.

This process enabled me to filter out irrelevant pages, leaving only the ones that needed further processing. This streamlined the process and reduced the cost by about 80% of the original estimate.

### A basic example

I will give you a simple example to showcase an implementation of a Python program that does a similar job. To implement this solution, you'll need to create a MySQL database that contains the information for each image and a ChromaDB vector database, which you will use to query the vector embeddings.

Here's a simple schema for the MySQL database:

```sql
CREATE TABLE documents (
    id BIGINT UNSIGNED PRIMARY KEY,
    name VARCHAR(255),
    file_path VARCHAR(255), # path of the document in the filesystem
);

CREATE TABLE document_pages (
    id BIGINT UNSIGNED PRIMARY KEY,
    document_id BIGINT UNSIGNED,
    type ENUM(‘invoice’, 'balance_sheet’, ‘income_sheet’, ‘none), # here we store the type of the image once we classify it
    file_path VARCHAR(255),
    FOREIGN KEY (document_id) REFERENCES documents(id)
);
```

We need to manually classify at least a couple hundred images and save them in a folder. The assigned type of each image should be contained in the name of the image, separated by a dash, for example: ```'[name]-invoice.jpg'``` or ```'[name]-none.jpg'```. Then, we will embed these images into a ChromaDB vector database using the following example:

```python
import chromadb
import glob
import os
import pytesseract as pt
from openai import OpenAI
import uuid

openai = OpenAI('your-api-key')

client = chromadb.PersistentClient(path="chromadb")

# create the classification chromadb collection
classification_collection = client.get_or_create_collection(name="classification_collection",  metadata={"hnsw:space": "cosine"})

classified_images = glob.glob("classified_images/*.jpg") # the location of the folder containing the manually classified images

for classified_image in classified_images:
    # get base name of image
    image_type = os.path.basename(classified_image).split(".")[0].split('-')[1]

    # get the ocr text
    ocr_text = pt.image_to_string(classified_image)

    embedding = openai.embeddings.create(
        input=ocr_text.lower(),
        model="text-embedding-ada-002"
    ).data[0].embedding

    # embed the image in the chromadb database
    classification_collection.add(
        embeddings=embedding,
        metadatas={'type': classified_image.type},
        ids = str(uuid.uuid4())
    )

```
After creating the classification database, you can use the following Python code to perform OCR, generate embeddings, and classify the pages of a given document page:

```python
from models import DocumentPage
import chromadb
import pytesseract as pt
from openai import OpenAI

openai = OpenAI('your-api-key')

client = chromadb.PersistentClient(path="chromadb")

# create the classification chromadb collection
classification_collection = client.get__collection(name="classification_collection")

for DocumentPage in DocumentPage.all():
    # get the ocr text
    ocr_text = pt.image_to_string(DocumentPage.file_path)

    embedding = openai.embeddings.create(
        input=ocr_text.lower(),
        model="text-embedding-ada-002"
    ).data[0].embedding

    # embed the image in the chromadb database
    query = classification_collection.query(
        query_embeddings=embedding,
        n_results=1
    )

    DocumentPage.type = query['metadatas'][0][0]['type']

    DocumentPage.save()
```

## Conclusion

This simple example should illustrate the process of classifying images using the latest trends in LLMs and vector databases. The synergy of OpenAI embeddings and ChromaDB vector databases has revolutionized our approach to document classification, making it more efficient and cost-effective. 

The article has given you a glimpse into the power of AI tools in business intelligence. As we continue to explore and experiment, we are excited about the endless possibilities that AI holds for us, and we will keep sharing our insights about how we can use them in real-world scenarios.


Uncover how OpenAI and ChromaDB revolutionized financial data extraction, streamlining document classification for efficiency.

Unleashing the Power of AI in Business Intelligence: Document Classification using OpenAI and ChromaDB

For over three years, we have relied on DigitalOcean's cloud infrastructure to deploy a myriad of applications, whether for our valued customers or our internal operations. The platform's seamless scalability, reliability, and user-friendly interface have ensured smooth deployments and operations, cementing our trust in its capabilities.

## Introducing DigitalOcean's Partner Pod Program

The Partner Pod Program is DigitalOcean's latest initiative aimed at creating a more partner-centric ecosystem. Unlike traditional partner programs, the Partner Pod allows partners to choose the benefits they receive, ranging from discounts and credits to Market Development Funds. This new approach provides a flexible partnership framework, ensuring a mutually beneficial relationship between DigitalOcean and its partners.

## Mutual Benefits: A Win-Win Scenario

Our customers stand to gain significantly through our partnership with DigitalOcean's Partner Pod. They will have access to a suite of cloud products, technical support, and training, which are essential for navigating the digital landscape effortlessly. Moreover, the co-marketing opportunities and marketing development funds provided through the Partner Pod Program will enable us to enhance our service offerings further. This partnership also signifies our continued commitment to leveraging cutting-edge technology to efficiently solve our customers' digital challenges.

## Navigating the Future Together

With the road ahead promising a plethora of opportunities, our partnership with DigitalOcean's Partner Pod is a testament to our resolve to elevate our service delivery continually. The collective expertise, shared knowledge pool, and synergy between Lexis Solutions and DigitalOcean will undoubtedly foster innovation, drive growth, and ensure our customers remain a step ahead in the digital curve.

---

Our journey with DigitalOcean's Partner Pod has set the stage for a collaborative venture that transcends traditional partnerships. It's not just about business growth; it's about setting new benchmarks in digital excellence, exploring the uncharted, and ensuring our clientele always has a competitive edge in the digital realm.

We're thrilled to announce our new strategic partnership with DigitalOcean Partner Pod, marking a milestone in our journey toward delivering superior digital solutions.

Lexis Solutions Joins the DigitalOcean Partner Pod Program

## Why choose Cypress

### Testing capabilities

Cypress has a friendly user interface that provides simple, human-friendly syntax, which makes it great for both beginners and experts. You can simulate user interactions like clicking buttons and filling out forms, making it perfect for testing your web applications thoroughly.

### Consistent cross-browser testing

Another of Cypress' benefits is that it supports multiple browsers, ensuring your application works well for all your users, regardless of which browser they prefer. In testing, this is helpful to identify and fix browser-specific issues early on in the development process.

### Community and documentation

Cypress has a relatively big community and excellent documentation. The community actively contributes, meaning you can find answers to your questions and difficulties. At the same time, there are also plenty of tips and even pre-written code snippets that are easily findable. Additionally, many people and channels contribute to the community by posting tutorials about practically everything you search for. There is also a well-maintained documentation website that provides clear explanations for every code snippet and good general guidance, making it easy to begin using Cypress and 
stay aware of the situation.

### Setting up your testing environment

__Installation and setup__

The first step in setting up your testing environment with Cypress is installing it on your device. Before attempting that, [make sure to check your device is compliant with the requirements from the documentation.](https://docs.cypress.io/guides/getting-started/installing-cypress#System-requirements) After that, you can start making a designated folder and name it correctly, as this will be your project folder. Afterward, open the code editor you prefer (I recommend VS Code, so let's use it for reference) and open the folder in the editor. The next step is to open your terminal in VS Code and to install Cypress in the project folder itself with the ```npm install Cypress --save-dev command```, after which, as soon as the installation finishes, you will have several files generated on the left side. By default, your tests will be written in the ```spec.cy.js``` file, but you can always change that and set it per your preferences. So far, this is all you need, and you can begin putting the configurations for your project.

[provided with freely accessible code from the article in a public Github repo for your convenience](https://github.com/radoslav-kosev/Cypress-Article-Reference-Code/commit/38d69947eab0ce8121f250f402f56da2fc5159a5)

__Project configuration__

In this step, you need to set the best testing environment specifications for your project, which you can do from [here](https://docs.cypress.io/guides/references/configuration). That means setting a specific browser to test with particular parameters like height and width, and you can also set a base URL to be tested, which means that you can avoid it as a step in your tests. Of course, some of these steps are non-obligatory, so excluding the ones you cannot test without, it is entirely up to you to set whatever pre-conditions you prefer. Remember that the available documentation will also give you plenty of other recommendations. You should check it out [here](https://docs.cypress.io/guides/references/configuration) to get some ideas. 

__Integrating with your application__

By this, I mean that before testing whatever website you're about to test, ensure it's accessible on the web and exceptionally reachable by Cypress. If it has any access limitations or restrictions, this would potentially interrupt the testing process or prevent it from starting.
Writing your first test

__Creating test files__

So, you set your project specifications, and now you must decide where to write your tests. Naturally, the first step is creating a test file, usually in the __e2e__ folder. Also, if your test file has a longer name - you can connect it with dashes - for example, ```'edit-my-profile-page.cy.js.'``` __Always remember that the extension for your testing suite files is not just ```.js``` it's ```.cy.js```.

Clear and precise name given to test files becomes a crucial part of keeping project cleanliness in time, and proper naming pays off as the number of tests increases. This is particularly evident for above, let's say, 100 tests.

__Writing the tests__

Here is the step where the essence of our job takes place: we begin writing tests. We will proceed here by considering that we already have test specifications prepared and reported test cases; now, we must transform the written scenarios into difficulties. 

Here is a simple overview of how it looks:

```js
describe('Most basic Google tests', () => {
    it('Successfully opens Google url', () => {
        cy.visit('https://www.google.com')
        cy.url().should(‘eq’, ‘https://www.google.com’)
    })
})
```

You begin by using ```describe()``` to define your whole test suite. It's good to clarify that the test suite contains as many tests as you want. Still, it's strongly recommended that all of them are related to one application module and that they are located in different folders - for example, the folder __Authentication__ should only contain the file ```authentication.cy.js```, the folder __Navigation__ bar should only contain ```navigation-bar.cy.js``` and likewise for home page, etc. If you're working on a more extensive website that can potentially have login options from a third party like Facebook or Google - you can have several files in the ```authentication.cy.js``` - one file for login with credentials, let's call it ```standard-login.cy.js```, Google login file called google-login.cy.js and a Facebook login file called ```facebook-login.cy.js```, etc. Let's analyze the test, which is supposed to check that the Google URL opens successfully. 

```js
describe(Most basic Google tests, () => { ... })
```

We give our suit a proper name (which often overlaps with the test file name)

```js
it('Successfully opens google.com', () => { ... })
```

Here is where we give our test a proper name specifically related to what it should do. This means that if the idea is for the test to visit a website successfully, then we should specify the "successful" part __*especially*__. That way, we can differentiate between positive and negative test scenarios еasier and not mess up with test names. After all, every test is supposed to test something different from all others, so the uniqueness in the name is a must.

```js
cy.visit('https://www.google.com')
```

The ```cy.visit()``` command instructs Cypress to visit a specific URL. This step cannot be skipped in any way, whatever you test, because Cypress is designed to test websites. Before writing your first command, it is an excellent reminder to refer to the documentation. Constant checks will save time, prevent code inconsistencies, and boost effectiveness.

```js
cy.url().should('eq', 'https://www.google.com')
```

In all honesty, this is the last but crucial part of the test, which a beginner QA is likely to forget once or twice. The *__assertion part__* is where we instruct our Cypress to compare the URLs it visited specifically and to check if they are __the same__. If they are not, Cypress didn't successfully visit the URL we told it to visit, or we were redirected, and the assertion will fail. And so will the whole test, respectively. 

__Running and debugging__

After writing our test, we can return to the terminal and note that the ```npx cypress``` is open to run Cypress. After that, click __E2E Testing__ from the window:

![cypress-1](//images.ctfassets.net/5gydaotbo8jm/78jCJtLqSdGKdMA7DEbkcw/8d72ffac46fa93880ece79f17ee493c6/1.png)

After you do that, this window will open:

![cypress-2](//images.ctfassets.net/5gydaotbo8jm/5QifhEKMH6cEGNiaMrcf76/92ff64aebb9ca01678aebdfbe46f65ed/2.png)

__Click Start E2E testing on the browser we choose;__ I recommend Chrome. That will open a new window containing the specs page. From here, you should select __Create new spec__:

![cypress-3](//images.ctfassets.net/5gydaotbo8jm/Kljp0yIokAD7XIzM1JhBs/c2ce7e10485bced6956a24b469d278ca/3.png)

And then you will see this:

![cypress-4](//images.ctfassets.net/5gydaotbo8jm/4hby1Qc1NelwT9g8TOy9iJ/44eaf57266abdc998b3cfef066f3aad9/4.png)

Directly click on Create spec and here:

![cypress-5](//images.ctfassets.net/5gydaotbo8jm/1rgAeIcTUJ68s2epBlkQWO/d21b74f66981fb235a2a8a5c807e08b5/5.png)

__Okay, run the spec.__
This will generate your first test from Cypress, and you can observe how the program runs the tests. 

The test will pass because everything assigned by default is correctly written. However, when we write a test, and it fails, Cypress offers a little bit of info to identify and fix the problem, such as what exactly __did not happen as expected__ and on __which line of code__ in your file. So you can inspect the application's state and understand why a test didn't behave as expected. 

You can now go back to your code editor at ```spec.cy.js```, the file that contains one automatically generated test, which is situated in the __e2e__ folder in __Cypress__ (```cypress/e2e/spec.cy.js```).

From here on, we can edit our file name according to our test coverage and edit the test correctly, like, for example, changing the name of the test suite, the name of the test itself, and also the website in the trial from example.cypress.io to www.google.com, the commands, etc., so that we can simply perform our first exploratory testing and see how Cypress works.

### Cypress best practices

__Pinpoint the objects you interact with__

Make the best possible use of the page elements (header, footer, login modal, search results field, etc.) when building your selectors. It will help you make a logically correct test that's easy to read and maintain. 
Let's say you're writing a test where you have to open a login modal via a button in the site's header. The right approach, in this case, is to incorporate the footer in the selector. Its ID can do this, or if it doesn't have one - by its __tag name__ and __class__. Chances are that you won't be the single QA in your company. Someone will look at your test and read: you open this site, in this site, you go to the footer, and within the footer, you click on a button that opens a login modal - plain and simple. It is understandable to read. 

I would also suggest that if you have no prior knowledge - you go through a crash course in HTML and CSS; it will expand your general idea of how they are built because we QAs interact with them all the time. 

__Write compact tests__

Think of test writing as if you're packing a suitcase - you want to include only the essentials, not have the whole house stuff. A proper test doesn't need to include steps that don't particularly add any use. You don't need to instruct Cypress to open a modal that doesn't need to be opened, just like you won't take knives and forks when you go to a restaurant. A compact test means no unnecessary code writing, saving time as unnecessary steps will not be executed. It's also a good idea to have your code prettier because it's natural to become messy when writing tests. A prettifier comes in handy to tidy up the code once you finish writing. [Here's the one I use for Visual Studio Code.](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode)

__Write versatile tests__

Writing versatile tests, from my perspective, means several things - in this case, we're talking about Cypress, which is JS-based. Therefore, almost all functions and capabilities of JS can be applied to test writing (such as loops, functions, variables, etc.) despite Cypress itself having its syntax. As for how to maximize the effectiveness of the tool to the best degree - we can make use of custom commands, for example. Suppose you have ten tests containing identical first two or three steps. You can combine the respective steps in one test. For example:

```js
Cypress.Commands.add('login', () => {
 cy.get('#username-input-field').type('My username')
 cy.get('#password-input-field').type('My password')
 cy.get('#login-button').click()
})
```

Afterward, this command, which we named 'login,' we can apply like this:

```js
describe('Authentication', () => {
  it('Successful login into the system', () => {
      cy.visit('https://www.mywebsite.com')
      cy.login()
      cy.url().should(‘contain’, ‘/profile’)
  })
})
```

This saves us the effort of writing the same steps for many tests and keeps tests cleaner, and when you make changes to the code, you just change only one place. All commands should be stored in the commands.js file, after which you can import them into the test file with 

```js
import '../../support/commands'
```

Also, include __constants__ in your tests to avoid magic numbers. If they're to be used in one test suite only, you can write them in the test files you're working with. Here is an example of how a constant can look if it's stored and used in one test file:

```js
const inputField = '#input-field’
```

However, if your const is to be used in three different test suites (which means three different files, respectively) - then you should consider creating a separate file called ```constants.js``` and store them there with the export keyword:

```js
export const PASSWORD_INPUT_FIELD = '#password-input-field’'
```

After that, to apply it in your desired test suite file, you should import it at the beginning of the file this way:

```js
import { PASSWORD_INPUT_FIELD } from '../../support/constants'
```

### Conclusion

For anyone considering a testing tool for their automation journey, I can confidently say that Cypress is an excellent choice. I've enjoyed using Cypress for over a year, and I can attest to its remarkable user-friendliness and various capabilities. If you're about to embark on your automation testing adventure, I strongly encourage you to try Cypress!

A brief overview of why Cypress is a great choice for testing, including installation, project setup, and optimal testing.

Cypress insider: How to set your Testing Environment and run your First Test


## A quick overview of Docker and Kubernetes

Before deploying our app to EKS, let's first quickly go over what Docker and Kubernetes are and how they help us deploy our applications. 

## Docker

Containerization is a technology that allows you to package your application and its dependencies into a single, portable unit called a container. Docker is the most popular containerization platform; it will enable you to encapsulate an application and its dependencies into a self-sufficient container, ensuring that it runs consistently across different environments, from a developer's PC to a production server. Docker containers are lightweight, fast to start, and easy to share, making them the ideal building blocks for modern applications. Containers ensure that what you develop and test locally behaves the same way in any environment where Docker is installed, eliminating the "but it was working on my machine" problem. All this helps speed up the development process, simplifies the deployment, and improves the overall reliability of applications.

## Kubernetes

On the other hand, Kubernetes is an open-source container orchestration platform that automates container deployment, scaling, and management. With Kubernetes, you can define how your applications should run, ensuring high availability, fault tolerance, and efficient resource utilization. 

A Kubernetes cluster comprises two fundamental components: the control plane (master node) and multiple worker nodes. The control plane oversees essential cluster-wide tasks like scheduling, scaling, and maintaining the desired state. On the other hand, the worker nodes serve as the execution engines, hosting pods—the smallest deployable units within Kubernetes. Each pod may contain one or more containers, sharing network and storage resources for efficient communication.  

Some of the main features of Kubernetes include: 

* __Orchestration:__ Kubernetes automates the deployment, scaling, and management of containerized applications, reducing manual work.
* __Load Balancing:__ It offers built-in load balancing for distributing network traffic to containers.
* __Auto-Scaling:__ Kubernetes can automatically scale the number of containers (pods) based on CPU or other metrics to handle changing workloads.
* __Self-Healing:__ It constantly monitors the state of your applications and automatically replaces containers if they fail.
* __Rolling Updates:__ Kubernetes supports rolling updates, allowing you to update your application without downtime or service interruption.
* __Resource Management:__ You can define and control resource limits and requests for CPU and memory, ensuring efficient resource utilization.

## Prerequisites

Before continuing with this article, make sure you have the following:

* An AWS account
* Access to the EKS (Elastic Kubernetes Service) and ECR (Elastic Container Registry) services on AWS
* The AWS CLI tool, we'll be using it to interact with the AWS services
* `kubectl`, the Kubernetes CLI tool
* `eksctl`, a CLI tool that will simplify our work with Amazon EKS, abstracting away the complexity of the AWS CLI
* Docker installed on your machine. We'll use it to build our app image and push it to the container registry

## Deploying the app

### Initial project setup

For this example, we will deploy a simple express hello world app. This is the initial project structure that we'll be working with

```text
hello-world-app
├── package.json
├── package-lock.json
└── src
    └── index.js
```

If we run the app, it should start on port 3000.

```sh
$ node src/index.js
App running on port 3000
```

And a `GET http://localhost:3000` request should return "Hello World!"

```sh
$ curl http://localhost:3000                          
Hello World!
```

## Containerizing the application

Before deploying our application to Amazon EKS, we need to build a Docker image and push it to Amazon's container registry. This registry serves as the centralized repository from which EKS retrieves the image, enabling the execution of our application in the cluster.

### Building the Docker image

Let's create two new files in the root directory of our project: "Dockerfile" and ".dockerignore".

```text
hello-world-app
├── package.json
├── package-lock.json
└── src
    └── index.js
├── Dockerfile
└── .dockerignore
```
Dockerfile is a script used to create a Docker image. It contains a series of instructions that describe how the image should be built. Here's the content of our Dockerfile:

```dockerfile 
FROM node:16

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000

CMD ["node", "src/index.js"]

```
__Let's break it down line by line:__

* `FROM node:16`: This instruction specifies the base image for building this Docker image. In this case, it starts with a Node.js version 16 base image, which already includes Node.js and npm, making it suitable for Node.js applications.
* `WORKDIR /app`: This instruction sets the working directory within the image to /app. This is where the rest of the commands will be executed.
* `COPY package*.json ./`: Here, the `COPY` instruction copies the package.json and package-lock.json files from the host (the directory where the Dockerfile is located) to the /app directory within the image. 
* `RUN npm install`: You can use `RUN` to run any command during the build process. In this case, we use npm to install the dependencies specified in the package.json file. 
* `COPY . .`: This instruction copies all the files and directories from the host into the /app directory in the image. 
* `EXPOSE 3000`: The `EXPOSE` instruction informs Docker that the container will listen on port 3000 when it runs. 
* `CMD ["node", "src/index.js"]`: The `CMD` instruction specifies the default command to run when a container based on this image is started. In this case, it runs the Node.js application by executing node src/index.js within the container, starting our app.

The .dockerignore file tells Docker what files should be ignored during the build. In this case, we can add node_modules so it doesn't get copied into the docker image. While not required, this helps us keep the image size small and improve the build time.

Now that we've created the Dockerfile, we can build the image using the `docker build` command:

```sh
$ docker build -t hello-world-app .
```

Using the `-t` flag, we've specified what we want to name our image. The dot at the end tells Docker to look for the Dockerfile in the current directory. If it's somewhere else, or you named your script file differently, you can use the `-f` flag to pass Docker the path to the file. Once the command has been executed, you can run `docker images` to get a list of available images. The output should look something like this:

```sh
REPOSITORY  	 TAG  		   IMAGE ID 	   CREATED  SIZE TAG
hello-world-app  ec5cdedc65fc  26 seconds ago  861MB    latest
```

### Pushing the image to ECR

Now that we've built the image, it's time to create a repository in ECR and push it there.

To create the repository, run the following command:

```sh
$ aws ecr create-repository --repository-name hello-world-app
```

You should see output similar to this:

```json
{
    "repository": {
        "repositoryArn": "arn:aws:ecr:eu-central-1:721145219880:repository/hello-world-app",
        "registryId": "721145219880",
        "repositoryName": "hello-world-app",
        "repositoryUri": "721145219880.dkr.ecr.eu-central-1.amazonaws.com/hello-world-app",
        "createdAt": "2023-10-05T13:26:15+03:00",
        "imageTagMutability": "MUTABLE",
        "imageScanningConfiguration": {
            "scanOnPush": false
        },
        "encryptionConfiguration": {
            "encryptionType": "AES256"
        }
    }
}
```

Take note of the `repositoryUri` value, which we'll use later to push our image to the repository and deploy it to the Kubernetes cluster. Still, before that, since this is a private repository, we need to authenticate Docker first. To do this, you can run the following command with your region and account ID:

```sh
$ aws ecr get-login-password --region [region] | docker login --username AWS --password-stdin [aws_account_id].dkr.ecr.[region].amazonaws.com
```

You will get a "Login Succeeded" message in the console if it succeeds.

Now that we've authenticated Docker, we can push our image to the repository. We must tag it with a specific value using the repositoryUri: `[repositoryUri]:[tag]`. The tag value here can be anything: an image version, "latest", or anything else that makes sense in your case. Then, you can run `docker push` with the same value you tagged the image with:

```sh
$ docker tag hello-world-app 721145219880.dkr.ecr.eu-central-1.amazonaws.com/hello-world-app:latest
```

```sh
$ docker push 721145219880.dkr.ecr.eu-central-1.amazonaws.com/hello-world-app:latest
```

Once the command executes, you can confirm that the image has been pushed to ECR by running:

```sh
$ aws ecr list-images --repository-name hello-world-app
```

```json
{
    "imageIds": [
        {
          "imageDigest": "sha256:511a3e2fef5790fca4ac7b03fec6dba0b5339c4acea8a74b7f1ea3fc16f5904f",
            "imageTag": "latest"
        }
    ]
}
```

With this, we've successfully built our image and pushed it to ECR. Now, it's time to deploy it to EKS.

## Deploying the app to EKS

First, we'll need to create a new cluster in EKS:

```sh
$ eksctl create cluster --name hello-world-app --region eu-central-1
```

Creating a new cluster might take a while. Once the command finishes executing, you should see in the terminal that it has created a new config file. In my case, it was at `~/.kube/config`. This file contains the credentials necessary for `kubectl` to access our cluster. 

We will create two new files to deploy the app to the Kubernetes cluster: `k8s/deployment.yaml` and `k8s/service.yaml`. 

```text
hello-world-app
├── k8s
	├── deployment.yaml
    └── service.yaml
├── package.json
├── package-lock.json
└── src
    └── index.js
├── Dockerfile
└── .dockerignore
```

The deployment.yaml file describes how the container should be run within the cluster. Here, we can specify the number of replicas, docker image, env variables, etc. On the other hand, the service.yaml file allows us to connect our app to a network. Let's examine the files' contents and explain them in more detail.

First the deployment.yaml file:

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: hello-world
  template:
    metadata:
      labels:
        app: hello-world
    spec:
      containers:
      - name: hello-world-container
        image: 721145219880.dkr.ecr.eu-central-1.amazonaws.com/hello-world-app:latest
        ports:
        - containerPort: 3000
```

* The `apiVersion` and `kind` fields are used to specify the kind of Kubernetes resource that's being defined. In this case it's deployment, which is used for deploying containerized applications. Still, many other resource types exist, like ConfigMap for storage configurations or PersistanceVolume for storage.
* The `metadata` section contains metadata about the deployment. 
* The `spec` section contains information about the deployment itself:
    * `replicas` specifies the number of running instances of your application.
    * `selector` defines what selector we can use later on to identify pods managed by this deployment
    * `template` contains the template of the pods. Here, we've configured the container, for example, what image should be used and what port is exposed. Here, you can also set other things, such as env variables, CPU and memory limits, data volumes for the container, and so on.

	And here's the service.yaml file:

```yaml
apiVersion: v1
kind: Service
metadata:
  name: hello-world-service
spec:
  selector:
    app: hello-world
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
  type: LoadBalancer
```

The service.yaml file will allow our deployment to connect to a network. In this case, the service will listen to port 80 and route the traffic to the container on port 3000.

One of the more important fields in this resource type is the type field, which decides who can access the app. There are four possible values:

* ClusterIP - the deployment won't be publicly accessible. It can only be accessed by other apps within the Kubernetes cluster.
* NodePort - this service type will open a port that we specify on all nodes in the cluster, making the deployment publicly available
* LoadBalancer - This is another way to expose the deployment to public access. Still, it only works if you use Kubernetes with a cloud provider that supports it (AWS, in our case). It will create a load balancer service to route the traffic to our pods.
* ExternalName - this will map our service to a DNS name. We can specify the name with the `spec.externalName` field.

And now, we're ready to deploy the app to the cluster by calling `kubectl apply` to apply the changes that we defined earlier to our cluster:

```sh
$ kubectl apply -f k8s/deployment.yaml 
deployment.apps/hello-world-deployment created
```

```sh
$ kubectl apply -f k8s/service.yaml   
service/hello-world-service created
```

Once this is done, we can check whether everything has been appropriately deployed by running:

```sh
$ kubectl get all

NAME  										READY 	STATUS  RESTARTS 	AGE
pod/hello-world-deployment-574fbf949b-5xcrf 1/1 	Running 0  			4m
pod/hello-world-deployment-574fbf949b-bfghm 1/1 	Running 0  			4m

NAME  						TYPE 			CLUSTER-IP  	EXTERNAL-IP PORT(S)  												 					AGE
service/hello-world-service LoadBalancer 	10.100.159.38 	a2c68e692ec944c48a22d7a8b10aff98-2831416.eu-central-1.elb.amazonaws.com 80:30955/TCP 	4m
service/kubernetes  		ClusterIP  		10.100.0.1  	<none>  443/TCP  																		17m

NAME 									READY 	UP-TO-DATE AVAILABLE 	AGE
deployment.apps/hello-world-deployment 	2/2 	2  			2 			4m

NAME  												DESIRED CURRENT READY	AGE
replicaset.apps/hello-world-deployment-574fbf949b 	2 		2 		2 		4m
```
Here, we can see all resources deployed to the cluster, including our two instances and the service. For `service/hello-world-service`, we can see it has been assigned an external IP address. Using that, we can test our app:

```sh
$ curl a2c68e692ec944c48a22d7a8b10aff98-2831416.eu-central-1.elb.amazonaws.com
Hello World!
```

As we can see, everything is working correctly. With this, we've finished our deployment.

You can find the complete project from this article here: https://github.com/lexis-solutions/kubernetes-demo.

### Conclusion
This article covers the basics of Docker and Kubernetes, essential components in modern application deployment. However, it's important to note that Docker and Kubernetes are vast and intricate topics with numerous advanced features and capabilities waiting to be explored. While we've provided a solid foundation to get you started, there's much more to discover and master in these powerful technologies.


Lexis Solutions guides you through the process of containerizing and deploying your application on an Amazon Web Services Kubernetes cluster using Elastic Kubernetes Service.

Deploying Your App to AWS Kubernetes with EKS: A Step-by-Step Guide

There are many good reasons why you should consider creating your own website for your business. From reaching more people and customers from all over the world to increasing your overall sales, having a website is crucial to your success in the digital age. Don’t let this opportunity slip away, get to work and start developing your own website with the support of our Lexis Solutions team.

We're on a mission to create amazing digital products for innovative ideas. Since 2017, we have worked with thriving businesses as their technological partner. Our skilled staff is dedicated to offering custom software solutions that properly match your vision while assuring excellent project management and transparent communication.

And today, we are delighted to announce that our team has recently accomplished a massive milestone for this year. Our company has been recently named one of the most-reviewed web development companies in Bulgaria by none other than The Manifest.

The Manifest, for those of you who don’t know, is [a business blog and reviews platform ](http://themanifest.com/bg/web-development/companies?utm_source=directory&utm_medium=blog&utm_campaign=TM+Awards)that aims to gather and verify the hard data, expert insights, and actionable advice that you need to build your brand and grow your business – to provide the practical business wisdom that manifests in your success.

This award wouldn’t have been possible without your support, yes you! You, our clients and partners, played a significant role in helping us bag this award. Our team is thankful for supporting our business throughout the years, you guys are awesome! 

[Let’s talk about your project.](https://www.lexis.solutions/contact-us) We’re a team of developers, designers, and strategists who work with companies of all sizes to design, build, and grow digital products.

The Manifest highlights another achievement by Lexis Solutions' team! 

The Manifest Recognizes Lexis Solutions as one of the Most Reviewed Web Developers in Bulgaria

## Introduction

In the early stages of my [software development](https://www.lexis.solutions/blog/from-idea-to-launch-software-development-for-startups) journey, I was tasked with a project that utilized "Power Apps," Microsoft's low/no-code platform. The experience with the low/no-code tech could have been more impressive and filled with shortcomings. As a result, I chose to stay away from low/no code development for the past few years. However, a recent opportunity within the company led me to the low/no-code ecosystem again, prompting me to explore a platform called [Bubble.io](https://bubble.io/).

### What is Bubble.io?

![cover (1)](//images.ctfassets.net/5gydaotbo8jm/6cnrh1ke0WzZyS0IrFGv0O/8e45bcf5b2e651bed9b506bdf3f67b67/cover__1_.png)

Bubble.io is one of the more popular no-code development frameworks.
The platform follows the "drag & drop" design approach using its visual editor, which allows anyone with or without a coding background to start immediately.

With the simple [UI](https://www.lexis.solutions/blog/free-resources-for-resourceful-UI-designers), it is easy to navigate, and with the search functionality, you can find what you are looking for without feeling overwhelmed.  

Nevertheless, its primary appeal lies with individuals lacking technical expertise who wish to create & design web applications, all without needing familiarity with the conventional tools of the industry.

### Visual Editor & UI Elements

By utilizing the visual editor, designing and building responsive apps can be done quickly and previewed immediately.

![design](//images.ctfassets.net/5gydaotbo8jm/6xZxBVNZqyUilmY7zdAoOf/e8ba365a9f51086ab51dbddac883ab84/design.png)

Inside the editor, you have access to various built-in UI elements. You can install new elements, or if you have knowledge of HTML & CSS, you can create your custom elements. Also, you can preview & deploy your app.

### Workflow Editor & Actions

The workflow editor is where you handle the app state; it lets you create actions and add logic to every element built inside the UI Builder.

![workflows](//images.ctfassets.net/5gydaotbo8jm/1Ps0IRockEp6qeWy8NXpgD/d0ad19682e5a10a17bbe2573375cbb66/workflows.png)

Inside the editor, you can assign dynamic or static variables during the different states of the page or when the input value is changed.

### Built-in Database

Bubble.io, the no-code development platform, creates a customizable & scalable database to meet all your needs and comes with privacy settings where you can set rules for what content is available for which user and so on.

![data](//images.ctfassets.net/5gydaotbo8jm/3NugOLHeohBaB2xJdyddyX/643693a2f96048aa5f1a15fc54a329f9/data.png)

### Styles and Re-usable components

In tradition, web development is a must to have clean and reusable UI elements to maintain and scale applications, and I am impressed that Bubble.io gives you the ability to have the same level of maintainability and scalability as traditional Javascript libraries such as [React](https://www.lexis.solutions/services/react-native-development).js.

![styles](//images.ctfassets.net/5gydaotbo8jm/1D2kRvdXbhwhEAELH1MLLu/25dce88307017b9055eb2abd15b6d697/styles.png)

Inside the style editor, you can apply and define the application layout theme and colours and design the templates for buttons, inputs, and so on. When the time comes to update/change any UI element, Bubble.io allows you to change the templates, which, as a result, will change all instances of that element.

### Plugins and Third-Party Integrations

Bubble.io has many pre-built and ready-to-be-used plugins, making third-party integrations such as Stripe and Google easy to set up and use. Of course, the no-code development platform provides the tools to create custom plugins, so any limitations on that front are covered.

![plugins](//images.ctfassets.net/5gydaotbo8jm/5KQi13vwbpPAz8eSwsXutt/d490918eae22297831c7ea1654e24646/plugins.png)

### What Bubble.io does well from a developer's point of view

With little prior experience with low/no-code development platforms, it was easy to start building a web application. When you create an account, you're led straight to the main dashboard; I read through the documentation to see how to work with plugins & workflows and was ready to go. The Bubble.io UI is intuitive and easy to navigate. I liked how the workflows work, and with the containers in the UI builder, it is easy to set element hierarchy and groups and have a responsive design. I could have a working MVP in a matter of hours, and I was impressed by how effortless it was.

### What Bubble.io doesn't do so well? 

After a few days of working with Bubble.io, and as my project grew in pages/elements/events, I started to experience different issues, mundane tasks to solve in traditional web programming but annoying and sometimes hard to solve in Bubble.io. After having hundreds of visual elements, it was challenging to make changes. When workflows grew in size and complexity, maintaining them and making changes became much more complicated.

## Conclusion

Overall, Bubble.io is one of the better low/no-code development platforms. It has reached a point worth considering as an alternative to traditional web development. Just like React.js and Angular.js, both libraries have their use cases. Strong and weak points, so for a simple application that may display information or is small in scale and with a simplistic UI, Bubble.io is an excellent option. For larger, more complex applications, I wouldn't use Bubble.io. However, this may change in the future as the platform keeps on improving.

Navigate the diverse terrain of no-code development as we unveil the capabilities of Bubble.io.

The Bubbles of No-Code Development: A Journey Through Bubble.io

## Introduction

Guzzle is a popular PHP HTTP client that simplifies making HTTP requests. It has been around for over ten years and is utilized by the Laravel framework under the hood. Guzzle abstracts the complexities of creating HTTP requests and handling responses by wrapping them in intuitive PHP objects, which you can easily manipulate. It is super flexible and allows you to specify timeouts, auth and proxy details, SSL certificates, etc. Guzzle is used for various HTTP-related tasks, such as making API requests, scraping web pages, and interacting with web services.

## Features

Guzzle has all the features you'd expect from an HTTP client. Here are some of its key functionalities in detail:
HTTP Request Methods & Params
Guzzle supports all primary HTTP request methods, including GET, POST, PUT, DELETE, HEAD. You can easily specify the desired manner when creating requests.

*__Get query without parameters__*

```php
    $client = new GuzzleHttp\Client();
    $request = $client->get('https://example.com');
```

*__Delete query__*

```php
    $client = new GuzzleHttp\Client();
    $request = $client->delete('https://example.com');
```

Guzzle also makes it easy to add parameters to your requests. This is useful for passing data in the URL for GET requests or specifying the body for the JSON API you interact with.

__Get query with parameters__

```php
    $client = new GuzzleHttp\Client();
    $response = $client->request('GET', 'https://example.com', [
        'query' => [
            'param1' => 'value1',
            'param2' => 'value2',
        ],
    ]);
```

 __Post query with parameter__

 ```php
    $client = new GuzzleHttp\Client();
    // Define the parameters as an associative array
    $parameters = [
        'param1' => 'value1',
        'param2' => 'value2',
    ];

    // Convert the parameters to a JSON string if there are two or more parameters, and skip this step if you pass only one parameter
    $json_ parameters = json_encode($parameters);
    // Send the POST request
    $response = $client->request (POST, 'https://example.com', [
        'body' => $json_ parameters,
        'headers' => [
            'Content-Type' => 'application/json',
        ],
    ]);
    // Get the response body if needed
    echo $response->getBody()->getContents();
``` 

You can set custom HTTP headers for your requests, essential for authentication, user agent identification, and specifying content types.

__Guzzle HTTP Client Authentication Example__

You can use Guzzle to send authenticated requests using various authentication methods such as Basic Authentication, Bearer Token, or other custom authentication mechanisms. Here's an example of basic authentication:
```php
    $client = new GuzzleHttp\Client();
    $response = $client->request('GET', 'https://example.com', [
        'auth' => [
            'your_username',
            'your_password'
        ],
    ]);
```

__Guzzle HTTP Client Specifying Content Types Example__

You can specify the Content-Type and Accept headers to indicate the content type of the request and the expected response content type:

```php
    $client = new GuzzleHttp\Client();
    $response = $client->request('POST', 'https://example.com', [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'key1' => 'value1',
            'key2' => 'value2',
        ],
    ]);
```

__Guzzle HTTP Client User Agent Identification Example__

You can set a custom User-Agent header to identify your client to the server:

```php
    $client = new GuzzleHttp\Client();
    $response = $client->request('GET', 'https://example.com', [
        'headers' => [
            'User-Agent' => MyCustomUserAgent/1.0,
        ],
    ]);
```

__Request Options__

Guzzle allows you to configure various request options, such as timeouts, SSL verification settings, and more.

```php
    // Timeout if a server does not respond in 5 seconds
    $client->request('GET', 'https://example.com', ['timeout' => 5]);

    // Automatically retry the request if a client or server error occurs - it is possible by installing an additional Guzzle Retry Middleware package via 'composer require caseyamcl/guzzle_retry_middleware'. Then, add an option in the request
    $response = $client->get('https://example.com', [
        'max_retry_attempts' => 5, // maximum number of retries. It is ten by default.
    ]);

    // *If you're using Laravel, you can set retries with this code where 3 is the number of request attempts, and 50 is the number of milliseconds Laravel should wait between shots
    Use Illuminate\Support\Facades\Http;
    $response = Http::retry(3, 50)->post('https://example.com');

    // Use a custom SSL certificate on disk
    $client->request('GET', '/', ['verify' => '/path/to/directory/certificate.pem']);
```

__Middleware__

Middleware is a powerful feature that enables you to modify requests and responses flexibly and reusable. You can attach middleware to the Guzzle client to perform tasks like logging, authentication, or response processing.

```php
    // An example of how to log Guzzle HTTP requests and responses for debugging purposes using the Monolog package, which sends logs to a file, and the MessageFormatter instance that controls what gets logged
    $logger = new Logger('guzzle');
    $logger->pushHandler(new StreamHandler('guzzle.log'));
    $stack = \GuzzleHttp\HandlerStack::create();
    $stack->push( \GuzzleHttp\Middleware::log(
        $logger,
        new MessageFormatter('{method} {uri} - {code} - {res_body}')
    ));
    $client = new GuzzleHttp\Client(['handler' => $stack]);
    $response = $client->request('GET', 'https://example.com');
```

__Cookies__

Guzzle includes a CookieJar for managing cookies in your HTTP requests. This allows your application to handle session and authentication cookies seamlessly.

```php
    // An example of managing cookies across multiple requests using CookieJar
    $cookieJar = new CookieJar();
    $client = new GuzzleHttp\Client(['cookies' => $cookieJar]);
    $response = $client->request('GET', 'https://example.com');
    $cookies = $cookieJar->toArray(); // Access cookies from the response
    print_r($cookies);
```

__Async Requests__

Guzzle supports asynchronous requests, which means you can send multiple requests in parallel and process their responses as they become available. This can significantly improve the performance of your applications when dealing with numerous remote resources.

```php
    // An example of how to send asynchronous requests for improved performance
    $client = new GuzzleHttp\Client();
    $api_urls = [
        'https://api.example.com/resource1',
        'https://api.example.com/resource2',
        'https://api.example.com/resource3',
    ];
    $promises = [];
    foreach ($api_urls as $url) {
        $promises[$url] = $client->getAsync($url);
    }
    $responses = Promise\settle($promises)->wait(); // A settled Promise represents the outcome of an asynchronous operation which can be successfully (fulfilled) or with an error (rejected)
    foreach ($responses as $url => $response) {
        if ($response['state'] === 'fulfilled') {
            $response_data = $response['value']->getBody()->getContents();
            echo "Response from $url: $response_data \n";
        } else {
            echo "Request to $url failed.\n";
        }
    }
```

__Streaming Responses__

Guzzle can stream large response bodies, which helps download large files or process streaming data without loading it all into memory.

```php
    // You can stream large responses to save memory
    $client = new GuzzleHttp\Client();
    $api_url = 'https://api.example.com/large-resource';
    $response = $client->request('GET', $api_url, ['stream' => true]);
    // Stream the response
    $stream = $response->getBody();
    while (!$stream->eof()) {
        echo $stream->read(1024); // Process data in chunks
    }
```

__Proxy support__

Proxy support in Guzzle allows you to route your HTTP request through an intermediary server (a proxy server) before reaching the target server. This can be useful when accessing resources behind a firewall or for privacy reasons. Guzzle makes configuring and using a proxy server for your requests is straightforward.

```php
    // An example of how to set proxy servers. Define the proxy server details
    $proxy_servers = [
        first_server => 'https://first-proxy-server:port',
        second_server => 'https://second-proxy-server:port',
    ];
    // Create a Guzzle HTTP Client with proxy configuration
    $client = new GuzzleHttp\Client([
        RequestOptions::PROXY => $proxy_servers,
    ]);
    // Sent a GET request through the proxy
    $response = $client->get('https://example.com');
    // Handle the response
    echo $response->getBody()->getContents();
```

__Sink__

Guzzle's "sink" feature allows you to efficiently download large files or responses directly to a file instead of loading the entire response into memory. This is particularly useful when dealing with large files, as it helps prevent memory exhaustion.

```php
    // An example of downloading a file with the sink function
    $client = new GuzzleHttp\Client();
    // Define the file path where you want to save the downloaded file
    $file_path = 'path/to/directory/file.txt';
    // Send a GET request and save the response directly to the file
    $client->get('https://example.com/large-file.zip', [
        RequestOptions::SINK => $file_path,
    ]);
```

__Error Handling__

The library provides error-handling mechanisms and exceptions for various HTTP-related errors, making it easier to handle issues like connection failures, timeouts, and invalid responses gracefully.

__Request and Response Logging__

Guzzle supports request and response logging, which is valuable for debugging and monitoring the communication between your application and external services.

  ```php
    // You can log both requests and responses for debugging. Create a PSR-3 compatible logger (e.g., Monolog)
    $logger = new \Monolog\Logger('guzzle');
    $logger->pushHandler(new \Monolog\Handler\StreamHandler('guzzle.log'));
    $stack = HandlerStack::create();
    $stack->push(Middleware::log($logger, new MiddlewareFormatter()));
    $client = new GuzzleHttp\Client(['handler' => $stack]);
    $api_url = 'https://api.example.com/resource';
    try {
        $response = $client->request('GET', $api_url);
        // Handle the response here
    } catch (Exception $e) {
        echo 'Error: ' . $e->getMessage();
    }
```
__Note:__ In this example, you must implement a custom MiddlewareFormatter to format the log entries per your requirements.
Scenarios

Certainly, Guzzle HTTP Client is commonly used in various scenarios in PHP development. Let's dive into the most common use cases for Guzzle, along with detailed examples for each:

*__Web Scraping and Content Retrieval__*

Scraping web content or fetching HTML data from websites.

```php
    $client = new GuzzleHttp\Client();
    $response = $client->get('https://example.com');
    $html_content = $response->getBody()->getContents();
```
*__Asynchronous Requests__*

Sending multiple HTTP requests in parallel for improved performance, e.g., concurrently fetching data from various APIs.
```php
    $client = new GuzzleHttp\Client();
    $promises = [
        $client->getAsync('https://api.example.com/resource1'),
        $client->getAsync('https://api.example.com/resource2'),
        // Add more async requests as needed
    ];
    // Wait for all promises to settle and get their results
    $responses = GuzzleHttp\Promise\unwrap($promises);
```
*__Authentication and Token Retrieval__*

Authenticating with an OAuth 2.0 server to obtain an access token for API access.

```php
    $client = new GuzzleHttp\Client();
    $response = $client->post('https://auth.example.com/token', [
        'form_params' => [
            'grant_type' => 'client_credentials',
            'client_id' => 'YOUR_CLIENT_ID',
            'client_secret' => 'YOUR_CLIENT_SECRET',
        ],
    ]);
    $token_data = json_decode($response->getBody()->getContents(), true);
```
__Web Service Testing__

Writing automated tests to check the functionality of a web service's API endpoints. You can use PHPUnit, a popular testing framework for PHP, to create and run these tests.
```php
    $client = new GuzzleHttp\Client();
    // Send a GET request to https://example.com/your-endpoint
    $response = $client->get('https://example.com/users/123');

    // Check if the response status code is 200, and then parse the JSON response content and make assertions about its structure and values
    $this->assertEquals(200, $response->getStatusCode());
    $data = json_decode($response->getBody(), true);
    $this->assertArrayHasKey('expected_key', $data);
    $this->assertEquals('expected_value', $data['expected_key']);
```
### Step-by-step with Guzzle HTTP Client

Picture yourself in the process of constructing a web application that needs to interact with various online services. Let's say you intend to retrieve video information from a video database and present it within your application. You will surely need an HTTP client, and Guzzle is the perfect choice. Let's start with authentication and then proceed with different download modes (synchronous and streaming). Follow these steps:

__1. Install Guzzle:__ If you haven't already, install Guzzle by running:
```
    composer require guzzlehttp/guzzle
```

__2. Create a PHP file:__ Start by creating a PHP file where you'll write the code for downloading the video.

__3. Import necessary classes:__ In your PHP file, you'll need to import the Guzzle classes you'll be using and include the “autoload” file in the script part of the code to load all the classes and methods.
```php
    <?php
    require 'vendor/autoload.php';
    Use GuzzleHttp\Client;
    Use GuzzleHttp\RequestOptions;
```
__4. Specify the URL of the video and authentication credentials:__ Set the URL of the video and any authentication credentials if required:

```php
    $username = 'your_username';
    $password = 'your_password';
    $video_url = 'https://example.com/path/to/video.mp4';
    $file_path = 'path/to/directory/video.mp4';
```

__5. Initialize Guzzle Client:__ Create an instance of the Guzzle Client. This client will handle the HTTP requests:

```php
    $client = new GuzzleHttp\Client([
        'auth' => [$username, $password]
    ]);
```

__6. Option 1:__ Synchronous Download: This method downloads the entire file simultaneously. Use this approach if you're working with reasonably sized files:

```php
    try {
        $client->get($video_url, [
            RequestOptions::SINK => $file_path,
        ]);
        echo 'Video downloaded successfully!';
    } catch (GuzzleHttp\Exception\RequestException $e) {
        echo 'Error: ' . $e->getMessage();
    }
```

__7. Option 2:__ Streamed Download: This method downloads the file in chunks, which can be helpful for large files. It consumes less memory compared to synchronous downloads:
 ```php
    try {
        $response = $client->request('GET', $video_url, [
            'auth' => [$username, $password], // Add authentication
            'stream' => true // Enable streaming
        ]);
        if ($response->getStatusCode() === 200) {
            $stream = $response->getBody();
            $file_handle = fopen('video.mp4', 'w');
            while (!$stream->eof()) {
                fwrite($file_handle, $stream->read(1024));
            }
            fclose($file_handle);
            echo 'Video downloaded successfully!';
        } else {
            echo 'Error: Status code - ' . $response->getStatusCode();
        }
    } catch (Exception $e) {
        echo 'Error: ' . $e->getMessage();
    }
```
Replace 'https://example.com/path/to/video.mp4', 'your_username', and 'your_password' with your actual URL and authentication credentials.

__Note:__ *Ensure you have the proper rights or permissions to download and use the video, considering any legal or copyright considerations.*

## Conclusion

Guzzle is an incredible HTTP Client for PHP because of its simplicity, flexibility, extensive feature set, security, and strong community support. Whether you're building web applications, APIs, or scripts that interact with remote services, Guzzle can streamline your HTTP-related tasks and enhance the overall quality of your projects.


Guzzle is an essential PHP HTTP client for API requests, web scraping, and streamlining requests with custom headers, timeouts, and methods.

From the front lines