.NET Foundation

• Actively contribute to the .NET Foundation through technical content creation.
• Contributing to open-source projects, enhancing software development and technology collaboratively.

Open Source Developer

XANT

Founder

• Designed and implemented software solutions for Build&Enjoy and Batalent startups, resulting in a remarkable 30% operational efficiency boost.
• Collaborated closely with business clients to gather and document unique requirements, generating detailed functional and technical specifications for seamless alignment between business goals and technical implementation.
• Developed custom Content Management Systems, enhancing content delivery and elevating user experience by an impressive 50%.
• Conducted Unit Testing and Integration Testing of Software, resulting in fewer bugs and defects.
• Authored comprehensive technical documents, streamlining project development and maintenance processes.
• Optimized code to significantly boost applications' performance and responsiveness, thereby enhancing user satisfaction.
• Debugged and resolved support-raised issues, improving overall customer satisfaction.
• Applied code reviews, ensuring the optimization of code and adherence to best coding practices.
• Actively incorporated modern architectural principles and industry best practices, contributing to the development of robust and scalable applications.
• Demonstrated a proactive approach to problem-solving, leveraging a genuine passion for tackling difficult challenges in diverse and challenging situations.
• Exhibited a strong passion for continuous learning, actively seeking opportunities to acquire and apply new skills and technologies in project work.

Software Engineer

• Engineered a customized accounting application tailored to the specific needs of a wood company, facilitating financial record-keeping, inventory management, and financial analysis, contributing to enhanced financial control and reporting.
• Developed a comprehensive patient management desktop application for a clinic, streamlining patient records, appointments, and billing processes, leading to a 30% increase in operational efficiency and improving patient care.
• Leveraged pre-designed templates and skillfully customized them to create captivating websites, customizing webpages, and enhancing user engagement through tailored layouts and various template optimizations.
• Successfully enhanced SEO across multiple websites by refining content, optimizing keywords, fine-tuning media elements, and meticulously optimizing individual pages, resulting in substantial improvement in user experience and an increase in organic traffic.
• Developed several JS website templates for clients, showcasing entrepreneurial skills and expanding the reach of high-quality web development products.

Full Stack Engineer

MonoLearn

• Led an extensive Machine Learning course for 30 master's students, covering advanced topics, guiding projects, and mentoring in applying ML techniques for field-specific challenges, while overseeing the implementation and analysis of 20 practical ML projects as part of the curriculum.
• Taught a comprehensive ASP.NET Core course, equipping students with the skills to develop web applications using the ASP.NET Core framework.
• Conducted C# classes, including Compact and Advanced C# courses, providing in-depth knowledge and practical skills in C# programming.

Software Development Instructor

• Produced over 200 professional Instagram posts about programming techniques and coding snippets, plus recording around 20 podcasts and videos combined.
• Facilitated private consultations with over 100 students through Instagram direct chat and WhatsApp voice calls, nurturing their software development ambitions.
• Conducted private programming sessions and live broadcasts to mentor newcomers in the coding world.

Technical Content Creator

City, University of London

• Conducted phone surveys for City Graduates Support, ensuring accurate data recording and maintaining confidentiality, and offered information on City Careers and Alumni services.
• Supported January 2024 Graduations as a Student Ambassador, managing crowds, answering guest questions, and assisting with venue logistics.
• Welcomed and registered guests at The Creative Edge Conference, providing them with name badges attached to neck lanyards, and assisting in event setup as needed.
• Assisted visitors during events, guiding them around campus, and addressing inquiries.

Marketing and Events Ambassador

University of Isfahan

• Collaborated with experts from the mechanical engineering department, applying machine learning expertise to address complex optimization challenges.
• Conducted advanced research to develop machine learning models addressing unique material behavior predictions.
• Applied deep learning techniques to analyze and optimize the performance of composite materials.
• Engineered novel algorithms to refine predictions and optimize material properties, fostering interdisciplinary problem-solving efforts.
• Implemented artificial neural networks for predictive modeling and analysis, integrating computer engineering methodologies with interdisciplinary optimization strategies.

Machine Learning Researcher

• Assisted in teaching "C++ Programming Fundamentals" to 40 students, improving their comprehension.
• Evaluated students' homework and provided constructive feedback.

 Programming Teaching Assistant

Mihanrayan

• Collaborated on HTML, CSS, and JavaScript coding tasks to contribute to various web projects.
• Performed practical testing and debugging to ensure the websites functioned smoothly and were user-friendly.
• Applied industry-standard front-end techniques to create user-friendly, visually appealing websites.
• Coordinated with UI/UX designers to integrate visual elements seamlessly into web projects.

Software Developer Intern

Full Stack Software Engineer | .NET Specialist | Master's Student at City, University of London

I'm a versatile Software Engineer with expertise in .NET, committed to crafting impactful solutions across diverse domains including software product development, SaaS platforms, and intricate system architectures. Prioritizing scalability and seamless integration with cloud services, I advocate for clean code, collaboration, and cutting-edge methodologies. My passion for AI/ML drives transformative innovations, while my dedication to open dialogue and collaborative creativity aims to enrich our community. 


If this resonates with you, let's connect!


Instagram & Twitter: @elliot1one

Reviewing SOLID Principles is always refreshing.

I created some slides to review them using C# language.

SOLID stands for 5 principles:
1. Single Responsibility Principle
2. Open/Close Principle
3. Liskov Substitution Principle
4. Interface Segregation Principle
5. Dependency Inversion Principle

These principles guide toward building more maintainable and robust software.

However, as with anything in software engineering, you don't need to follow them constantly. 

The key to understanding them is to apply them while considering the trade-offs involved in each decision. 

Let's review them together. Also, let me know if you have faced any difficulties applying them.


♻ Reshare with your friends.
🚀 Keep exploring .NET with (Elliot One).

#cleancode #designpatterns #softwareengineering #systemdesign #dotnet

Elliot One

SOLID Principles Explained in C# by Elliot One

𝐂𝐚𝐜𝐡𝐢𝐧𝐠 is a critical element of building a robust system.

It stores frequently accessed data for faster future response.

𝐈𝐧-𝐌𝐞𝐦𝐨𝐫𝐲 𝐂𝐚𝐜𝐡𝐢𝐧𝐠 is one of the techniques for that.

It is easily implementable in ASP.NET Core using IMemoryCache.

Note that the application data will reside on the server's instance.

In-Memory Caching has these advantages:
-  Fetching rapidly and Increasing performance
-  Best suited for small applications 
-  Deployed on a single server
-  Easy to impelement

Also, certain disadvantages:
-  It might waste the server's resources
-  It can be costly for longer periods
-  The costs increase with application scaling
-  Data will be lost after server failure


You should be familiar with 4 𝐨𝐩𝐭𝐢𝐨𝐧𝐬 to implement it appropriately.

1. Priority
2. Size
3. Sliding Expiration
4. Absolute Expiration

Sliding Expiration helps expire the cache entry if it's not used by anyone for that particular period, whereas Absolute Expiration ensures the expiration even if the sliding expiration doesn't let expiration.


Review the slides to explore this mechanism.


♻ Reshare with your network.
🔔 Keep exploring new concepts with (Elliot One).


#aspnetcore #dotnet #csharp #systemdesign #softwareengineering


ASP.NET Core In-Memory Caching by Elliot One

Senior Full Stack Engineer | Sharing Practical Tips on .NET, System Design, and Architecture

𝐀𝐬𝐲𝐧𝐜𝐡𝐫𝐨𝐧𝐨𝐮𝐬 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 is a critical art to master.

It empowers you to build more 𝐫𝐞𝐬𝐩𝐨𝐧𝐬𝐢𝐯𝐞 and 𝐬𝐜𝐚𝐥𝐚𝐛𝐥𝐞 solutions.

In C#, the 𝐚𝐬𝐲𝐧𝐜/𝐚𝐰𝐚𝐢𝐭 mechanism facilitates the async development.


By marking a method with async keyword, you tell that the method contains asynchronous code.

When invoking an async method, await keyword ensures that the program waits for the competition of the task. This allows the application to continue the execution of other tasks while this task is being completed.

It's good to notice that Task class is part of the 𝘛𝘢𝘴𝘬 𝘗𝘢𝘳𝘢𝘭𝘭𝘦𝘭 𝘓𝘪𝘣𝘳𝘢𝘳𝘺 (𝘛𝘗𝘓), designed to simplify parallel and asynchronous operations in .NET.


I created a comprehensive set of slides to explore async programming in C#. 

Review the slides carefully to master async in C#.


♻ Reshare with your network.
🔔 Keep exploring .NET with (Elliot One).

#dotnet #csharp #softwareengineering #softwaredevelopment #programming


C# Asynchronous Programming Explained by Elliot One

Cancellation Tokens in .NET signal that a task should be canceled.

They allow cooperative cancellation of a task or operation.

Two ways to check if a cancellation token is requested are:
-  IsCancellationRequested Property
-  ThrowIfCancellationRequested Method


Cancellation Token is used to create a token and signal cancellation to the associated tokens. It can be retrieved from CancellationTokenSource.

When a cancellation is requested, the OperationCanceledException will be raised and it should be handled gracefully.

This exception is being raised by calling ThrowIfCancellationRequested on a token.


It's a good practice to include cancellation tokens in I/O operations. You should also consider using them in HTTP calls.


This will ensure responsive behavior and efficient resource management. Moreover, it prevents deadlocks while improving system consistency and predictability.



Do you use cancellation tokens?


♻ Reshare with your friends.
🚀 Keep exploring .NET with (Elliot One).
 

#csharp #dotnet #softwareengineering #systemdesign

.NET Cancellation Token Explianed by Elliot One

𝐂𝐚𝐜𝐡𝐢𝐧𝐠  is more challenging in 𝒅𝒊𝒔𝒕𝒓𝒊𝒃𝒖𝒕𝒆𝒅 𝒔𝒚𝒔𝒕𝒆𝒎𝒔.

𝐃𝐢𝐬𝐭𝐫𝐢𝐛𝐮𝐭𝐞𝐝 𝐂𝐚𝐜𝐡𝐢𝐧𝐠 is a powerful caching technique in ASP.NET Core to rescue.

It is easily implementable in ASP.NET Core using IDistributedCache.

𝐑𝐞𝐝𝐢𝐬 can be integrated easily into it, providing a scalable and robust caching mechanism.

This approach is suitable for both small-scale and large-scale applications.

Pros of Redis Distributed Caching:
-  Horizontally Scalable
-  High Performance
-  High Availability

Cons of that:
-  Complicated Configuration
-  Network Overhead and Latency
-  Cost


Consider setting the Sliding Expiration and Aboslute Expiration values to ensure the cache expires at a reasonable time. This will ensure that you will not provide stale data to the clients.


You can also review In-Memory Caching Here: [https://lnkd.in/eqGJyVwF]


Review the slides to explore this more deeply.


♻ Reshare with your network.
🔔 Keep exploring new concepts with (Elliot One).


#aspnetcore #dotnet #csharp #systemdesign #softwareengineering

ASP.NET Core Distributed Caching by Elliot One

Retrieving 𝐫𝐞𝐥𝐚𝐭𝐞𝐝 𝐞𝐧𝐭𝐢𝐭𝐢𝐞𝐬 is a huge part of using 𝐄𝐅 𝐂𝐨𝐫𝐞.

While you can use Include(), this is prone to forgetfulness.

If you always need to retrieve related entities, simply use 𝐀𝐮𝐭𝐨𝐈𝐧𝐜𝐥𝐮𝐝𝐞().

This feature simplifies the eager loading of related entities.

All you need is to apply AutoInclude while configuring the entity.


Now, you shouldn't worry about the entity's state anymore. You will always get the related entities when loading the entity.


The only catch is that what if you don't want to always include?

Using 𝐈𝐠𝐧𝐨𝐫𝐞𝐀𝐮𝐭𝐨𝐈𝐧𝐜𝐥𝐮𝐝𝐞𝐬() in your query is the answer.


Comment your opinion about this feature.

♻ Reshare with your network.
🔔 Keep exploring new concepts with (Elliot One).

#efcore #dotnet #cleancode


EF Core AutoInclude Explained by Elliot One

𝐇𝐚𝐧𝐝𝐥𝐢𝐧𝐠 𝐞𝐱𝐜𝐞𝐩𝐭𝐢𝐨𝐧𝐬 in web applications is paramount.

𝐆𝐥𝐨𝐛𝐚𝐥 𝐞𝐱𝐜𝐞𝐩𝐭𝐢𝐨𝐧 𝐡𝐚𝐧𝐝𝐥𝐢𝐧𝐠 is a popular mechanism for that.

IExceptionHandler interface was introduced in ASP .NET Core 8.


This interface is integrated with the built-in exception handler middleware.

There is a "𝐓𝐫𝐲𝐇𝐚𝐧𝐝𝐥𝐞𝐀𝐬𝐲𝐧𝐜()" method to handle the exception. When the exception can be handled, the true value should be returned.

Also, the 𝐈𝐄𝐱𝐜𝐞𝐩𝐭𝐢𝐨𝐧𝐇𝐚𝐧𝐝𝐥𝐞𝐫 service should be registered within the Program.cs. 

𝐄𝐱𝐜𝐞𝐩𝐭𝐢𝐨𝐧𝐇𝐚𝐧𝐝𝐥𝐞𝐫𝐌𝐢𝐝𝐝𝐥𝐞𝐰𝐚𝐫𝐞is also used to add the middleware to the request pipeline.


𝐏𝐫𝐨𝐛𝐥𝐞𝐦𝐃𝐞𝐭𝐚𝐢𝐥𝐬 can be helpful here to generate a response for common exceptions.


Explore the slides to see how this works.


♻ Reshare with your friends.
🔔 Keep exploring .NET with (Elliot One).

#dotnet #cleancode #systemdesign

ASP.NET Core Global Exception Handler by Elliot One

𝐒𝐭𝐫𝐨𝐧𝐠𝐥𝐲-𝐭𝐲𝐩𝐞𝐝 configurations are truly powerful.

𝐎𝐩𝐭𝐢𝐨𝐧𝐬 𝐏𝐚𝐭𝐭𝐞𝐫𝐧 is ASP.NET Core helps to simplify app configurations.

At times you need to pass configurations to classes.

These configurations can reside in:
-  Environment Variables
-  Appsettings.json
-  User Secret

You should create a class with corresponding properties that binds to the respective properties.

The structure of the class should match the exact section of the configuration file you aim to bind.

When configuring the binding, you can also specify to 𝐯𝐚𝐥𝐢𝐝𝐚𝐭𝐞 the values of configuration properties. This increases application safety and ensures proper setup.


There are three ways to access the options then:

1.  𝐈𝐎𝐩𝐭𝐢𝐨𝐧𝐬<𝐓> that is registered as singletone and read the configuration at the start. It will change if the application restarts or reloads configurations.

2.  𝐈𝐎𝐩𝐭𝐢𝐨𝐧𝐬𝐒𝐧𝐚𝐩𝐬𝐡𝐨𝐭<𝐓> that is scoped and reads configuration on every request. It shouldn't be injected into singleton services, and it has the latest updates value of an option during a request.

3.  𝐈𝐎𝐩𝐭𝐢𝐨𝐧𝐬𝐌𝐨𝐧𝐢𝐭𝐨𝐫<𝐓> that is registered as singltone, and helps to retrieve the most updated value of an option.


♻ Reshare with your network.
🔔 Keep exploring .NET with (Elliot One).


#aspcore #csharp #dotnet #softwareengineering #cleancode

ASP.NET Core Options Pattern by Elliot One

𝐑𝐞𝐟𝐥𝐞𝐜𝐭𝐢𝐨𝐧 helps to inspect and manipulate objects at runtime.

This dynamic mechanism offers useful functionalities:
-  Flexibility and Extensibility to modify applications at runtime
-  Retrieving information about types
-  Accessing and modifying object properties
-  Invoking methods dynamically


These potentials make reflection an important part of many internal tools, frameworks, and libraries.

You can also 𝐢𝐧𝐯𝐨𝐤𝐞 𝐦𝐞𝐭𝐡𝐨𝐝𝐬 𝐝𝐲𝐧𝐚𝐦𝐢𝐜𝐚𝐥𝐥𝐲 that increase the application flexibility and enable the 𝐩𝐥𝐮𝐠-𝐢𝐧 𝐩𝐚𝐭𝐭𝐞𝐫𝐧 to work seamlessly.

It's also good to know that 𝐨𝐛𝐣𝐞𝐜𝐭 𝐬𝐞𝐫𝐢𝐚𝐥𝐢𝐳𝐚𝐭𝐢𝐨𝐧, 𝐝𝐞𝐩𝐞𝐧𝐝𝐞𝐧𝐜𝐲 𝐢𝐧𝐣𝐞𝐜𝐭𝐢𝐨𝐧, and 𝐨𝐛𝐣𝐞𝐜𝐭 𝐦𝐚𝐩𝐩𝐢𝐧𝐠 functionalities are all built using reflection capabilities.


Review the slides thoroughly as I provided the code for all of these.


♻ Reshare with your network.
🔔 Keep exploring .NET with (Elliot One).

#csharp #dotnet #softwareengineering

C# Reflection Explained by Elliot One

Asynchronous operations are critical to having responsive applications.

Task.WhenAll() and Task.WhenAny() are two of the good methods to be aware of.

Task.WhenAll() shines when you need to await the completion of multiple intended tasks.

It has the following characteristics:
1.  Takes a collection of tasks.
2.  Returns a single task that completes when all supplied tasks have finished executing.
3.  Prefered when you need to perform some actions after all tasks have finished executing.


Task.WhenAny() is invaluable when you need the result from the fastest task among a set of async operations.

Its characteristics are:
1.  Accepts a collection of tasks.
2.  Returns the outcome of the swiftest async operation.
3.  Prefered when you need to perform some actions after the quickest task has finished executing.


Have you used these methods?


♻ Reshare the post to help your network.
🔔 Stay tuned with (Elliot One).

#csharp #dotnet #systemdesign


Task.WhenAll and Task.WhenAny in .NET by Elliot One

You will be dealing with images in your web app.

Image manipulation will be part of your application development at some point.

You might need to:
-  Change Image Dimensions
-  Change Image Aspect Ratio
-  Apply Filters on images

Here, ImageSharp library in .NET will come to survival. It is a straightforward library to be used in your web application.

It supports different image types and formats while providing over 40 common image processing operations.

Some of the key features provided by it are:
-  Image Loading and Saving
-  Image Processing
-  Drawing and Text Rendering
-  Filters and Effect
-  Metadata Editing
-  Colors Spaces and Formats

It's also good news to know that it is a cross-platform library and it's not tied to Windows image APIs.


In the slides, I demonstrated its usage in CSharp and ASP.NET Core. 
Review them thoroughly and let me know your thoughts.


♻ Reshare with your friends.
🚀 Keep exploring .NET with (Elliot One).

#csharp #dotnet #softwareengineering #systemdesign

Image Manipulation in .NET by Elliot One

Switch Expression is the modern way of writing switches in C#.

It is like an expression that helps evaluate multiple conditions.

Also, it can be combined with pattern matching, providing stronger matching capabilities.


"when", "and", "is", "or" keywords help to simplify logical statements here.

The "when" keyword helps to match additional conditions. "is" helps to evaluate an expression based on a given type, whereas "and"/"or" are used to mix multiple conditions.


The good news is that switch expressions can be even more concise using Expression-bodied members syntax.


Are you currently using switch expressions?


♻ Reshare the post to help your network.
🔔 Stay tuned with (Elliot One).

C# Switch Expressions Explained by Elliot One

Constructors are an important concept in OOP.

C# 12 introduced Primary Constructors. 

This new syntax helps to reduce boilerplate code.

The parameters you define in the primary constructor are passed to the body members without the need to declare private fields.

Private fields to back the parameters are generated automatically behind the scenes.

This modern approach eases property initialization, dependency injection, and assignment of parameters to the base class.

However, some developers still don't use this feature.

What do you think about it?
Do you actively use it? 

 
♻ Reshare with your network.
🚀 Keep exploring .NET with (Elliot One).

C# Primary Constructors Explained by Elliot One

Pattern Matching is a game-changer feature!

In C#, you can use a variety of pattern-matching techniques.

They help to reduce verbosity and get rid of many if-else statements.

This also improves code readability and cleanness, while it increases understandability.


Pattern Matching is useful to:
-  Determine an expression against a criteria
-  Checking against null values
-  Find matches in switch expressions


However, there several patterns that can be daunting to understand.

I compiled this post with all of the below patterns:
-  Declaration and Type Patterns
-  Constant Pattern
-  Relational Patterns
-  Logical Patterns
-  Property Pattern
-  Positional Pattern
-  var Pattern
-  Discard Pattern
-  Parenthesized Pattern
-  List Pattern


As you see it's an extensive list. 
Spend some time to familiarize yourself with them.


♻ Reshare the post to help your network.
🔔 Stay tuned with (Elliot One).


#csharp #dotnet #cleancode #softwareengineering #softwaredevelopment #programming

C# Pattern Matching Explained by Elliot One

Finding elements with a property's min/max value is a practical feature.

Modern LINQ provides two specific methods for that:

1. MinBy() can retrieve the element with minimum value based on the criteria. 
2. MaxBy() does the same for maximum value.


These new methods help to improve your codebase and make it cleaner.


In the previous versions, you should use OrderBy() and OrderByDescending() to achieve the same functionality.

Also, it's good to be aware of the Min() and Max() methods and not confuse them with the methods above. These two methods only operate on the types that have already implemented IComparable interface.


Let me know what you think about these methods.


♻ Reshare the post to help your network.
🔔 Stay tuned with (Elliot One).


 #csharp #dotnet #cleancode

LINQ MinBy and MaxBy Simplified by Elliot One

𝐑𝐞𝐬𝐩𝐨𝐧𝐬𝐞 𝐂𝐨𝐦𝐩𝐫𝐞𝐬𝐬𝐢𝐨𝐧 is beneficial to speed up web apps.

It helps 𝐫𝐞𝐝𝐮𝐜𝐞 𝐭𝐡𝐞 𝐬𝐢𝐳𝐞 𝐨𝐟 𝐝𝐚𝐭𝐚 sent to the clients.

This size reduction results in faster response and better user experience.


Configuring this in ASP.NET Core is pretty straightforward.

All you need is the 𝐑𝐞𝐬𝐩𝐨𝐧𝐬𝐞𝐂𝐨𝐦𝐩𝐫𝐞𝐬𝐬𝐢𝐨𝐧 middleware.

You can then include specific behaviors like:
-  Adding HTTPS Support
-  Including custom MIME Types
-  Providing Response Compression Algorithms

𝐁𝐫𝐨𝐭𝐥𝐢 and 𝐆𝐙𝐢𝐩 are the default providers in ASP.NET Core.


✅ The trade-off between response speed and compression level should be carefully considered while deciding the compression level.


Have you utilized this middleware before?


♻ Reshare with your friends.
🔔 Keep exploring .NET with (Elliot One).


ASP.NET Core Response Compression Simplified by Elliot One

𝐌𝐨𝐝𝐮𝐥𝐚𝐫 𝐜𝐨𝐧𝐟𝐢𝐠𝐮𝐫𝐚𝐭𝐢𝐨𝐧 of entities improves code organization. 

In 𝐄𝐅 𝐂𝐨𝐫𝐞 you apply custom configurations on your entities at times.

However, if you put all the configuration in the application 𝐝𝐛𝐂𝐨𝐧𝐭𝐞𝐱𝐭 𝐜𝐥𝐚𝐬𝐬, that will get cluttered soon.


The better approach is to define 𝐬𝐭𝐫𝐨𝐧𝐠𝐥𝐲 𝐭𝐲𝐩𝐞𝐝 𝐜𝐨𝐧𝐟𝐢𝐠𝐮𝐫𝐚𝐭𝐢𝐨𝐧 𝐜𝐥𝐚𝐬𝐬𝐞𝐬.

Simply using the 𝘈𝘱𝘱𝘭𝘺𝘊𝘰𝘯𝘧𝘪𝘨𝘶𝘳𝘢𝘵𝘪𝘰𝘯𝘴𝘍𝘳𝘰𝘮𝘈𝘴𝘴𝘦𝘮𝘣𝘭𝘺() method helps that.


In this approach:
-  Code is more modular
-  SOC principle applied
-  Code organization improved
-  Testability and Maintainability increased


After defining all the configurations, they can be applied in one go.

A specific method in ModelBuilder enables you to scan an 𝐚𝐬𝐬𝐞𝐦𝐛𝐥𝐲 and apply all the configuration classes automatically.


Review the slides for better understanding.


♻ Reshare with your network.
🔔 Keep exploring with (Elliot One).

#efcore #dotnet #cleancode #softwareengineering

Taplio

Elliot One's Linkedin Analytics

Elliot One

Elliot One's Best Posts (last 30 days)

Want to drive more opportunities from LinkedIn?

Taplio

.css-1jgreyo{background-image:linear-gradient(284deg, rgba(39,43,72,1) 0%, rgba(33,47,183,1) 100%);color:transparent;-webkit-background-clip:text;background-clip:text;}Elliot One's Linkedin Analytics

Elliot One

Elliot One's Best Posts .css-qqfgvy{font-size:var(--chakra-fontSizes-md);}(last 30 days)

Want to drive more opportunities from LinkedIn?

Elliot One's Linkedin Analytics

Elliot One's Best Posts (last 30 days)