DEV Community: Vengat

We Built Teckiypad to Fix What’s Broken in Remote Coding Interviews

Vengat — Tue, 03 Mar 2026 16:20:58 +0000

Remote interviews are broken.

Developers don’t trust the process.
Interviewers don’t trust the results.
And now AI tools make it even harder to assess real skill.

So we built Teckiypad.

Not just another online code editor.
Not just another assessment platform.
But a real interview simulation environment.

🔍 What’s Wrong With Most Platforms?

Let’s be honest.

Most coding platforms today:

❌ Feel like online judges

❌ Encourage memorization

❌ Don’t simulate real interview pressure

❌ Can’t detect AI-assisted cheating

❌ Don’t help candidates think independently

💡 What Makes Teckiypad Different?

Teckiypad is built from both interviewer and developer perspective.

It focuses on:

Real-time collaborative coding
Whiteboard for system design
Mock interview sessions
Online assessments
AI feedback
Camera + screen recording
Plagiarism detection
AI cheating detection
Hiring pipeline tracking
But here’s the important part 👇

👨‍💻 For Developers: Self Practice Without Seeing the Answer

Most platforms train you to:

“See solution → memorize pattern → repeat.”

That doesn’t build thinking ability.

Teckiypad helps candidates:

Practice without answer exposure
Solve in a real interview-like environment
Work under time constraints
See structured feedback
Review their session later
Improve communication skills
It’s not just about solving the problem.

It’s about:

Explaining your thought process
Writing clean code
Managing time
Handling edge cases
Thinking under pressure

We built it to simulate real-world interviews, not just algorithm drills.

🧠** How It Helps Developers Reach the Solution**

Instead of just marking pass/fail, Teckiypad:

Tracks coding behavior
Analyzes typing patterns
Detects copy/paste attempts
Gives AI-based structured feedback
Shows where the candidate struggled
Highlights complexity improvements
Developers can:
Rewatch their own mock session
Improve problem-solving strategy
Identify weak areas
Build interview confidence
It becomes a training tool, not just an evaluation tool.

If you're a:

Developer preparing for interviews

Hiring manager tired of fake profiles

Startup founder hiring remotely

You can try it here:

👉 https://teckiypad.com

Would love feedback from the dev.to community.

Snowflake SQL Unique Functions

Vengat — Sat, 04 Nov 2023 02:53:32 +0000

🔍 Discover Snowflake's powerful SQL functions for semi-structured data:
🔹 ARRAY_CONSTRUCT: Create arrays with ease! .
🔹 ARRAY_CONSTRUCT_COMPACT: Want an array without NULLs?
🔹 OBJECT_CONSTRUCT: Key-value pairs become JSON objects
🔹 OBJECT_CONSTRUCT_COMPACT: Skip the NULL values and get a clean object.

Let me know if you are interested to know more about this SQL functions and its use case.

Snowflake #snowflakedevelopers #snowflake #dataengineering

Spark Executor Memory Breakdown -short

Vengat — Sun, 08 Oct 2023 17:50:52 +0000

🚀 Spark Executor Memory Breakdown 🚀

When optimizing our Spark jobs, understanding the composition of executor memory is paramount. Here’s a deep dive:

✨ User Memory (UM):

Role: Memory utilized for Spark RDDs, DataFrames, and user-created objects.
Key tasks: Storing data structures, RDDs, and more.
✨ Reserved Memory (RM):

Approximately 300MB.
Reserved exclusively for Spark’s internal operations.
✨ Execution Memory (EM):

Role: Handles computational tasks.
Key processes: Shuffles, joins, sorts, and aggregations.
🔍 Total Executor Memory: The complete memory is the cumulative sum: Executor Memory = UM + RM + EM

Diving into these details empowers us to better allocate resources for our Spark applications, ensuring efficient operations and optimal performance.

ApacheSpark #BigData #MemoryManagement #SparkOptimization

Snowflake + ChatGPT Integration

Vengat — Wed, 04 Oct 2023 22:51:52 +0000

Hey folks! 🎉
Today, I played around with combining #Snowflake #streamlit and #ChatGPT to answer questions about customers. It feels like having a chat with my database! 😄
A quick look at what I did:

It's fun to see how a few lines of code can bring data to life in a chat. If anyone's interested in more details, let me know! 👍

DataMagic #SimpleCode #SnowflakeMeetsChatGPT

Using Python to Access Google Bard: A Simple Guide on Session Cookies

Vengat — Tue, 26 Sep 2023 15:58:22 +0000

Google Bard is a fantastic tool many have been waiting to explore programmatically. While direct API access might not be available to everyone, thanks to developers like Daniel Park, we have workarounds. He introduced the bardapi Python package, which leverages session cookies to interact with Google Bard. In this guide, I'll walk you through how to use this package.

Getting Started:
1. Prerequisites:

Python 3.x
Google Bard account
Basic knowledge of web developer tools in browsers

2. Installation:
If you haven’t already, install the bardapi package:

pip install bardapi

Retrieving Your Session Cookies:

Session cookies are essential for maintaining a user session, which the bardapi package uses to authenticate against Google Bard.

Steps to retrieve session cookies:

Navigate to the Google Bard website on a browser and log in.
Press F12 or right-click on the webpage and select 'Inspect' to open developer tools.
Navigate to the Application tab.
In the left sidebar, expand the Cookies section under Storage.
Select accounts.google.com or a similar domain. Here you'll find a list of cookies.
Look for the __Secure-1PSID cookie and note its value.

from bardapi import Bard
import os

#Replace BBBBBBB with the values you get from __Secure-1PSID 
os.environ['_BARD_API_KEY']="BBBBBBB"

# set your input text
input_text = "what is google bard?"

print(Bard().get_answer(input_text)['content'])

Above code may not work if you have multi session cookies, if that case replace above code with below,

You need to set multi cookie value. Using Bard Cookies Object.

from bardapi import BardCookies

cookie_dict = {
    "__Secure-1PSID": "Your ID",
    "__Secure-1PSIDTS": "Your Id",
    # Any cookie values you want to pass session object.
}

bard = BardCookies(cookie_dict=cookie_dict)
print(bard.get_answer('Tell me more about Bard"))

I hope you found this guide on accessing Google Bard using Python and session cookies insightful. Your feedback fuels my passion for sharing knowledge, so if you appreciated this article, please give it a thumbs up and share your thoughts in the comments below.

For more insights and to stay connected, you can find me on:

LinkedIn
Teckiy
Twitter
Thank you for reading, and I look forward to engaging with you on these platforms!

Custom Model Managers In Django

Vengat — Mon, 25 Sep 2023 06:11:30 +0000

Custom Model Managers In Django
A manager is an interface through which database query operations are provided to Django models. At least one Manager exists for every model in a Django application, objects is the default manager of every model that retrieves all objects in the database.

However, one model can have multiple model managers, we can also build our own custom model managers by extending the base manager class.

Creating Custom Model Managers
`class Post(models.Model):
title = models.CharField(max_length=200)
content = models.TextField()
active = models.BooleanField(default=False)

def __str__(self):
    return self.title`

objects is the default model manager for every model, therefore Post.objects.all() will return all post objects.

The objects method is capable of doing all basic **QuerySets **then why would we need a custom model manager?

Why would we need Custom Model Manager

To add extra Manager methods.
To modify the initial QuerySet the Manager returns.
Let’s create a model manager to retrieve all the published posts.

Using the objects manager published posts can be retrieved with the following query.

Lets create some dummy data using Django Shell,

>>  Post.objects.filter(active=True) Out: <QuerySet [<Post: Fourth Post>, <Post: First post>]>

>> <QuerySet [<Post: Fourth Post>, <Post: First post>]>

We will build a custom model manager called publish to retrieve the published posts.

class PublishManager(models.Manager):
    def get_queryset(self):
        return super(PublishManager, self).get_queryset().filter(active=True)

class Post(models.Model):
    .. our fields

    objects = models.Manager()  # The default manager.
    publish = PublishManager()  # Our custom manager.

    def __str__(self):
        return self.title

Now we can retrieve posts with the custom model manager as follows.

>> Post.published.all()   
>> <QuerySet [<Post: First post>, <Post: Fourth Post>]>

>> Post.objects.filter(active= True)     
>> <QuerySet [<Post: First post>, <Post: Fourth Post>]>

Hope this would help you to understand the basic idea about custom model manager.

Teckiy Developer Support

Vengat — Wed, 04 Nov 2020 00:23:09 +0000

I would like to share my recent experiences about Open source support in https://www.teckiy.com/.

This platform provides support for open source framework as per SLA's. Its like Stack Overflow & Freelancing concept.